assertEquals(0, SMBUtil.readInt2(buffer, offset + 2));

        // Verify Reserved (4 bytes at offset+4, should be 0)
        assertEquals(0, SMBUtil.readInt4(buffer, offset + 4));

        // Verify file ID is copied correctly (16 bytes starting at offset+8)
        byte[] copiedFileId = new byte[16];
        System.arraycopy(buffer, offset + 8, copiedFileId, 0, 16);
        assertArrayEquals(testFileId, copiedFileId);
    }

   * otherwise create, cache and return" pattern.
   *
   * @since 11.0
   */
  void put(K key, V value);

  /**
   * Copies all of the mappings from the specified map to the cache. The effect of this call is
   * equivalent to that of calling {@code put(k, v)} on this map once for each mapping from key

        projectBuilder = getContainer().lookup(ProjectBuilder.class, "classpath");
    }

    @Test
    void testProjectClasspath() throws Exception {
        File f = getFileForClasspathResource(DIR + "project-with-scoped-dependencies.xml");

        MavenProject project = getProjectWithDependencies(f);

        Artifact artifact;

        assertNotNull(project, "Test project can't be null!");

        NtlmMessage.writeSecurityBuffer(dest, 0, 4, null);
        assertArrayEquals(before, dest, "Zero length should leave dest unchanged");
    }

    @Test
    @DisplayName("writeSecurityBuffer copies data and sets fields")
    void testWriteSecurityBufferNonZero() {
        byte[] dest = new byte[8 + 4];
        byte[] payload = { 0x55, 0x66, 0x77 };
        NtlmMessage.writeSecurityBuffer(dest, 0, 8, payload);

            assertTrue(result > 0);

            // Verify header
            for (int i = 0; i < 8; i++) {
                assertEquals((byte) 0xFF, testBuffer[i]);
            }

            // Verify name was copied
            byte[] nameCheck = new byte[testName.length];
            System.arraycopy(testBuffer, 8, nameCheck, 0, testName.length);
            assertArrayEquals(testName, nameCheck);
        }

        @Test

        // Each name should write at least 34 bytes (encoded name + scope)
        assertTrue(bytesWritten >= 68);
    }

    @Test
    @DisplayName("writeTrailerWireFormat with scope should handle scoped names")
    void testWriteTrailerWireFormatWithScope() {
        when(mockCalledName.getName()).thenReturn("SERVER");
        when(mockCalledName.getNameType()).thenReturn(0x20);

            guid[i] = (byte) i;
        }

        // Call the method
        int bytesRead = response.readBytesWireFormat(guid, 0);

        // Assertions
        // When CAP_EXTENDED_SECURITY is set, it only copies GUID but doesn't update bufferIndex
        assertEquals(0, bytesRead);
        assertArrayEquals(guid, serverData.guid);
        assertEquals("", serverData.oemDomainName);
    }

    @Test

            int i = threadLocalCount.get();
            threadLocalCount.set(i + 1);
            return i;
          }
        };

    List<Future<Integer>> futures = executor.invokeAll(Collections.nCopies(10, incrementTask));

    for (int i = 0; i < 10; i++) {
      Future<Integer> future = futures.get(i);
      assertTrue("Task should have been run before being returned", future.isDone());

	extern GoInt64 MyFunction(int arg1, int arg2, GoString arg3);
	extern struct MyFunction2_return MyFunction2(int arg1, int arg2, GoString arg3);

found in the _cgo_export.h generated header, after any preambles
copied from the cgo input files. Functions with multiple
return values are mapped to functions returning a struct.

Not all Go types can be mapped to C types in a useful way.
Go struct types are not supported; use a C struct type.

            // When
            int bytesWritten = copy.encode(buffer, startIndex);

            // Then
            assertEquals(HEADER_SIZE, bytesWritten);

            // Verify source key is copied correctly
            for (int i = 0; i < SOURCE_KEY_SIZE; i++) {
                assertEquals(sourceKey[i], buffer[startIndex + i], "Source key byte at position " + i + " doesn't match");
            }
        }