t.Fatalf("Should find saved record")
	}
}

func TestNestedTransactionWithBlock(t *testing.T) {
	var (
		user  = *GetUser("transaction-nested", Config{})
		user1 = *GetUser("transaction-nested-1", Config{})
		user2 = *GetUser("transaction-nested-2", Config{})
	)

	if err := DB.Transaction(func(tx *gorm.DB) error {
		tx.Create(&user)

        def absoluteNestedFile = new File(baseDir, 'child/nested').absoluteFile
        assertEquals("child${File.separator}nested".toString(), baseDirConverter.resolveAsRelativePath(absoluteNestedFile))
        assertEquals("child${File.separator}nested".toString(), baseDirConverter.resolveAsRelativePath(absoluteNestedFile.absolutePath))

        assertEquals("child${File.separator}nested".toString(), baseDirConverter.resolveForDisplay(absoluteNestedFile))

          "name": "instance",
          "unspecified": "bar"
        },
        "spec": {
        }
      }
    }
  }
}
`, expectedPruned: []string{"nested.spec.embedded.spec.unspecified", "nested.spec.embedded.unspecified", "nested.spec.unspecified", "nested.unspecified", "pruned.spec.unspecified", "pruned.unspecified", "unspecified"}},
		{name: "x-kubernetes-embedded-resource, with root=true", json: `
{
  "apiVersion": "foo/v1",

          "name": "instance"
        },
        "spec": {
          "unspecified": "bar"
        }
      }
    }
  }
}
`, expectedUnknownFields: []string{
			"nested.metadata.unspecified",
			"nested.spec.embedded.metadata.unspecified",
			"preserving.metadata.unspecified",
			"pruned.metadata.unspecified",
		}},
		{name: "x-kubernetes-embedded-resource, with includeRoot=true", json: `
{

        }

        @Nested
        public Object getBean() {
            return bean;
        }
    }

    public static class TaskWithNestedIterable extends TaskWithAction {
        Object bean;

        @Inject
        public TaskWithNestedIterable(Object nested) {
            bean = nested;
        }

        @Nested
        public List<?> getBeans() {

            containsMultiLineString(
                """
                nested: my.Nested.Extension
                nested{} my.Nested.Extension
                beans: org.gradle.api.NamedDomainObjectContainer<my.Nested.Extension>
                beans{} org.gradle.api.NamedDomainObjectContainer<my.Nested.Extension>
                bar
                baz
                """
            )
        )

				"88d4266fd4e6338d13b845fcf289579d209c897823b9217da3e161936f031589",
			},
		},
		{
			desc:       "Nested hash reader NewReader() should merge.",
			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "", 4),
			size:       4,
			actualSize: 4,
		},
		{
			desc:       "Incorrect sha256, nested",
			src:        mustReader(t, bytes.NewReader([]byte("abcd")), 4, "", "", 4),
			size:       4,
			actualSize: 4,

		t.Errorf("expected cause when wrapped, got %v: %#v", ok, cause)
	}

	nested := fmt.Errorf("twice: %w", wrapped)
	if cause, ok := StatusCause(nested, "SomeCause"); !ok || cause != err.ErrStatus.Details.Causes[0] {
		t.Errorf("expected cause when nested, got %v: %#v", ok, cause)
	}
}

func BenchmarkIsAlreadyExistsWrappedErrors(b *testing.B) {

}

// SetNestedSlice sets the slice value of a nested field.
// Returns an error if value cannot be set because one of the nesting levels is not a map[string]interface{}.
func SetNestedSlice(obj map[string]interface{}, value []interface{}, fields ...string) error {
	return SetNestedField(obj, value, fields...)
}

// SetNestedStringMap sets the map[string]string value of a nested field.

        then:
        def e = thrown(IllegalStateException)
        e.message == 'Cannot append text as there is no current node.'
    }

    interface Thing<T> extends List<Nested>, Map<Nested, ? extends Consumer<? super T>> {
        interface Nested {
            class Inner {}
        }
    }