}
        };

    assertTrue(iter.hasNext());
    assertEquals(0, (int) iter.next());

    // verify idempotence of hasNext()
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertEquals(1, (int) iter.next());

    assertFalse(iter.hasNext());

    // Make sure computeNext() doesn't get invoked again
    assertFalse(iter.hasNext());

	if elem == nil {
		return nil, nil
	}
	return iterToValue(elem.Iter)
}

func iterToValue(iter simdjson.Iter) (*sql.Value, error) {
	switch iter.Type() {
	case simdjson.TypeString:
		v, err := iter.String()
		if err != nil {
			return nil, err
		}
		return sql.FromString(v), nil
	case simdjson.TypeFloat:
		v, err := iter.Float()
		if err != nil {
			return nil, err
		}
		return sql.FromFloat(v), nil

		}
		return v, nil
	case simdjson.TypeObject:
		obj, err := iter.Object(nil)
		if err != nil {
			return nil, err
		}
		return *obj, err
	case simdjson.TypeArray:
		arr, err := iter.Array(nil)
		if err != nil {
			return nil, err
		}
		iter := arr.Iter()
		var dst []any
		var next simdjson.Iter
		for {
			typ, err := iter.AdvanceIter(&next)
			if err != nil {
				return nil, err
			}

        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        Iterator iter = set.iterator();
        assertTrue(set.size() == 4, "Set size should be 4, is " + set.size());

        while (iter.hasNext()) {
            Artifact artifact = (Artifact) iter.next();
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()

        StringBuilder buffer = new StringBuilder("ManagedVersionMap (" + size() + " entries)\n");
        Iterator<String> iter = keySet().iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            buffer.append(key).append('=').append(get(key));
            if (iter.hasNext()) {
                buffer.append('\n');
            }
        }
        return buffer.toString();
    }

        StringBuilder ret = new StringBuilder().append(proto).append(":").append(server).append("[").append(endpoint);
        if (options != null) {
            final Iterator iter = options.keySet().iterator();
            while (iter.hasNext()) {
                final Object key = iter.next();
                final Object val = options.get(key);
                ret.append(",").append(key).append("=").append(val);
            }
        }

        if ((coreExtensions.getExtensions() != null)
                && (coreExtensions.getExtensions().size() > 0)) {
            for (Iterator iter = coreExtensions.getExtensions().iterator(); iter.hasNext(); ) {
                CoreExtension o = (CoreExtension) iter.next();
                writeCoreExtension(o, "extension", serializer);
            }
        }
        serializer.endTag(NAMESPACE, tagName);

        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        Iterator iter = set.iterator();
        assertTrue(set.size() == 4, "Set size should be 4, is " + set.size());

        while (iter.hasNext()) {
            Artifact artifact = (Artifact) iter.next();
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()

			if err != nil {
				t.Fatal(err)
			}
			i := pj.Iter()
			cpy := i
			b, err := cpy.MarshalJSON()
			if err != nil {
				t.Fatal(err)
			}
			if false {
				t.Log(string(b))
			}
			// _ = os.WriteFile(filepath.Join("testdata", tt.name+".json"), b, os.ModePerm)

		parser:
			for {
				var next simdjson.Iter
				typ, err := i.AdvanceIter(&next)
				if err != nil {
					t.Fatal(err)

			r.err = &in.Error
			return
		}
		if in.Value == nil {
			if in.Error == io.EOF {
				return
			}
			continue
		}
		i := in.Value.Iter()
	readloop:
		for {
			var next simdjson.Iter
			typ, err := i.AdvanceIter(&next)
			if err != nil {
				r.err = &err
				return
			}
			switch typ {
			case simdjson.TypeNone:
				break readloop