diff a/test/lib/jdk/test/lib/hprof/model/JavaClass.java b/test/lib/jdk/test/lib/hprof/model/JavaClass.java
--- a/test/lib/jdk/test/lib/hprof/model/JavaClass.java
+++ b/test/lib/jdk/test/lib/hprof/model/JavaClass.java
@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
@@ -71,10 +71,13 @@
     // Size of an instance, including VM overhead
     private int instanceSize;
     // Total number of fields including inherited ones
     private int totalNumFields;
 
+    // Size of the instance in the object of the class is inlined.
+    // Calculated lazily.
+    private int inlinedInstanceSize = -1;
 
     public JavaClass(long id, String name, long superclassId, long loaderId,
                      long signersId, long protDomainId,
                      JavaField[] fields, JavaStatic[] statics,
                      int instanceSize) {
@@ -112,10 +115,50 @@
     public void resolve(Snapshot snapshot) {
         if (mySnapshot != null) {
             return;
         }
         mySnapshot = snapshot;
+
+        // Resolve inlined fields. Should be done before resolveSuperclass for correct field counting
+        Snapshot.ClassInlinedFields[] inlinedFields = snapshot.findClassInlinedFields(id);
+        if (inlinedFields != null) {
+            int newCount = fields.length;
+            for (Snapshot.ClassInlinedFields f: inlinedFields) {
+                if (f.synthFieldCount == 0) {
+                    // Empty primitive class. just skip it - no data there.
+                    continue;
+                }
+                JavaHeapObject clazz = snapshot.findThing(f.fieldClassID);
+                if (clazz instanceof JavaClass fieldClass) {
+                    fieldClass.resolve(snapshot);
+
+                    // Set new field.
+                    fields[f.fieldIndex] = new InlinedJavaField(f.fieldName, 'Q' + fieldClass.getName() + ';', fieldClass);
+                    newCount -= (f.synthFieldCount - 1);
+                    // Reset invalid fields.
+                    for (int i = 1; i < f.synthFieldCount; i++) {
+                        fields[f.fieldIndex + i] = null;
+                    }
+                } else {
+                    // The field class not found.
+                    System.out.println("WARNING: class of inlined field not found:" + getName() + "." + f.fieldName);
+                }
+            }
+
+            // Set new fields.
+            JavaField[] newFields = new JavaField[newCount];
+            int oldIndex = 0;
+            for (int i = 0; i < newFields.length; i++) {
+                while (fields[oldIndex] == null) {
+                    oldIndex++;
+                }
+                newFields[i] = fields[oldIndex];
+                oldIndex++;
+            }
+            fields = newFields;
+        }
+
         resolveSuperclass(snapshot);
         if (superclass != null) {
             ((JavaClass) superclass).addSubclass(this);
         }
 
@@ -126,10 +169,11 @@
         for (int i = 0; i < statics.length; i++) {
             statics[i].resolve(this, snapshot);
         }
         snapshot.getJavaLangClass().addInstance(this);
         super.resolve(snapshot);
+
         return;
     }
 
     /**
      * Resolve our superclass.  This might be called well before
@@ -375,10 +419,53 @@
      */
     public int getInstanceSize() {
         return instanceSize + mySnapshot.getMinimumObjectSize();
     }
 
+    public int getInlinedInstanceSize() {
+        if (inlinedInstanceSize < 0) {
+            int size = 0;
+            for (JavaField f: fields) {
+                if (f instanceof InlinedJavaField inlinedField) {
+                    size += inlinedField.getInlinedFieldClass().getInlinedInstanceSize();
+                } else {
+                    char sig = f.getSignature().charAt(0);
+                    switch (sig) {
+                        case 'Q': {
+                            System.out.println("WARNING: (getInlinedInstanceSize) field "
+                                    + getClazz().getName() + "." + f.getName()
+                                    + " is not inlined, but has Q-signature: " + f.getSignature());
+                        } // continue as 'L' object
+                        case 'L':
+                        case '[':
+                            size += mySnapshot.getIdentifierSize();
+                            break;
+                        case 'B':
+                        case 'Z':
+                            size += 1;
+                            break;
+                        case 'C':
+                        case 'S':
+                            size += 2;
+                            break;
+                        case 'I':
+                        case 'F':
+                            size += 4;
+                            break;
+                        case 'J':
+                        case 'D':
+                            size += 8;
+                            break;
+                        default:
+                            throw new RuntimeException("unknown field type: " + sig);
+                    }
+                }
+            }
+            inlinedInstanceSize = size;
+        }
+        return inlinedInstanceSize;
+    }
 
     /**
      * @return The size of all instances of this class.  Correctly handles
      *          arrays.
      */
