{Name: "Name3", DBName: "name3", BindNames: []string{"Name3"}, DataType: schema.String, Tag: `gorm:"<-"`, Creatable: true, Updatable: true, Readable: true},
		{Name: "Name4", DBName: "name4", BindNames: []string{"Name4"}, DataType: schema.String, Tag: `gorm:"<-:create"`, Creatable: true, Updatable: false, Readable: true},

        for (String name : expectedNames) {
            bb.put(name.getBytes(StandardCharsets.UTF_16LE));
            bb.putShort((short) 0);
        }

        referral.decode(testBuffer, 0, testBuffer.length);

        assertArrayEquals(expectedNames, referral.getExpandedNames());
    }

		return []Name{
			ObjectManyVersions,
			ObjectLargeVersions,
			PrefixManyFolders,
		}
	case Everything:
		res := make([]Name, objectSingleTypesEnd-1)
		for i := range res {
			res[i] = Name(i + 1)
		}
		return res
	default:
		return []Name{name}
	}
}

// Mask returns the type as mask.
// Compound "All" types are expanded.
func (name Name) Mask() uint64 {

        assertFalse(name1.equals(name2));
    }

    @Test
    void equals_withBothNullScope_shouldReturnTrue() {
        Name name1 = new Name(mockConfig, "TEST", 0x20, null);
        name1.scope = null;
        Name name2 = new Name(mockConfig, "TEST", 0x20, null);
        name2.scope = null;

        assertTrue(name1.equals(name2));
    }

    @Test

      return 0;
    }
  }

  private static NamedObject named(String name) {
    return new NamedObject(name);
  }

  private static class NamedObject {
    private final Set<String> peerNames = new HashSet<>();

    private final String name;

    NamedObject(String name) {
      this.name = Preconditions.checkNotNull(name);
    }

    @CanIgnoreReturnValue

        rDataLengthField.setAccessible(true);
        rDataLengthField.set(response, 67); // 1 + 18 * 3 + 6 + 6 = 67 (3 names example)

        // Number of names
        src[srcIndex] = 0x03; // 3 names

        // First name entry (18 bytes)
        String name1 = "WORKSTATION     ";
        System.arraycopy(name1.getBytes("US-ASCII"), 0, src, srcIndex + 1, 16);
        src[srcIndex + 16] = 0x00; // hex code

        assertEquals(engine2, retrievedByClass);

        // But original names should still work
        assertEquals(engine1, scriptEngineFactory.getScriptEngine("name1"));
        assertEquals(engine2, scriptEngineFactory.getScriptEngine("name2"));
    }

    // Test with engine that has very long class name
    @Test
    public void test_add_longClassName() {

     *            return names for SIDs corresponding to local accounts for which the domain controller is not an
     *            authority.
     * @param tc
     *            The context that should be used to communicate with the named server.
     * @param sids
     *            The SIDs that should be resolved. After this function is called, the names associated with the SIDs

environment variables work in a similar way for C++ code.

# Go references to C

Within the Go file, C's struct field names that are keywords in Go
can be accessed by prefixing them with an underscore: if x points at a C
struct with a field named "type", x._type accesses the field.
C struct fields that cannot be expressed in Go, such as bit fields
or misaligned data, are omitted in the Go struct, replaced by

                // Multi-module project: artifactId may match any declared module name
                message = String.format(
                        "Cannot attach artifact to project: groupId and version must match the project, "
                                + "and artifactId must match either the project or a declared module name.%n"
                                + "  Project coordinates:  %s:%s:%s%n"