assertEquals("4.0.0", project4.getModelVersion());

        Build build = project4.getBuild();
        List<Plugin> plugins = build.getPlugins();

        Map<String, Integer> validPluginCounts = new HashMap<>();

        String testPluginArtifactId = "maven-compiler-plugin";

        // this is the plugin we're looking for.
        validPluginCounts.put(testPluginArtifactId, 0);

            }

            if (name.startsWith("!")) {
                reverseName = true;
                name = name.substring(1);
            }

            String sysValue = properties.getProperty(name);

            String propValue = property.getValue();
            if (propValue != null && !propValue.isEmpty()) {
                boolean reverseValue = false;
                if (propValue.startsWith("!")) {

     */
    private int currentPageNumber;

    /**
     * Crawling information ID.
     */
    public String id;

    /**
     * Session ID for the crawling session.
     */
    public String sessionId;

    /**
     * Creation time of the crawling information.
     */
    public String createdTime;

    /**
     * Clears all pagination state and crawling information fields.

 */
@ExtendWith(MockitoExtension.class)
class SmbComLockingAndXTest {

    /**
     * Helper for setting a field via reflection.
     */
    private static void setField(Object target, String name, Object value) {
        try {
            Field f = target.getClass().getDeclaredField(name);
            f.setAccessible(true);
            f.set(target, value);
        } catch (Exception e) {

        assertNotNull(instance);

        // Write something to verify it uses our test stream
        instance.println("test message");
        instance.flush();
        String output = testOutput.toString();
        assertTrue(output.contains("test message"));
    }

    @Test
    void testSetInstanceMultipleTimes() {
        // Test setting instance multiple times

        @DisplayName("Should create mock with string name")
        void testMockWithStringName() {
            String nameStr = "MOCK_CONTEXT";
            MockCreateContextResponse mock = new MockCreateContextResponse(nameStr);

            assertArrayEquals(nameStr.getBytes(StandardCharsets.UTF_8), mock.getName());
        }

        @Test
        @DisplayName("Should handle null string name")

	// }
	import "C"
	import "unsafe"

	func main() {
		cs := C.CString("Hello from stdio")
		C.myprint(cs)
		C.free(unsafe.Pointer(cs))
	}

A few special functions convert between Go and C types
by making copies of the data. In pseudo-Go definitions:

	// Go string to C string
	// The C string is allocated in the C heap using malloc.
	// It is the caller's responsibility to arrange for it to be

     */
    public static NtlmPasswordAuthentication authenticate(final CIFSContext tc, final HttpServletRequest req,
            final HttpServletResponse resp, final byte[] challenge) throws IOException {
        String msg = req.getHeader("Authorization");
        if (msg != null && msg.startsWith("NTLM ")) {
            final byte[] src = Base64.decode(msg.substring(5));
            if (src[8] == 1) {

    int flags, desiredAccess, searchAttributes, fileAttributes, creationTime, openFunction, allocationSize;

    // flags is NOT the same as flags member

    SmbComOpenAndX(final String fileName, final int access, final int flags, final ServerMessageBlock andx) {
        super(andx);
        this.path = fileName;
        command = SMB_COM_OPEN_ANDX;

        desiredAccess = access & 0x3;

					if e, ok := v.Exprs[0].(Expr); ok {
						sql := strings.ToUpper(e.SQL)
						wrapInParentheses = strings.Contains(sql, AndWithSpace) || strings.Contains(sql, OrWithSpace)
					}
				}
			case AndConditions:
				if len(v.Exprs) == 1 {
					if e, ok := v.Exprs[0].(Expr); ok {
						sql := strings.ToUpper(e.SQL)
						wrapInParentheses = strings.Contains(sql, AndWithSpace) || strings.Contains(sql, OrWithSpace)
					}
				}
			case Expr: