int i, ch, st, eq;

        st = eq = 0;
        for (i = 0; i < in.length; i++) {
            ch = in[i];
            if (ch == '&') {
                if (eq > st) {
                    final String p = new String(in, st, eq - st);
                    if (p.equalsIgnoreCase(param)) {
                        eq++;
                        return new String(in, eq, i - eq);
                    }

        doThrow(new IllegalArgumentException("invalid share/service")).when(session).getSmbTree(eq(share), eq(service));

        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> session.getSmbTree(share, service));
        assertTrue(ex.getMessage().contains("invalid"));
        verify(session).getSmbTree(eq(share), eq(service));
    }

    // Edge: unknown service returns null per stub
    @Test

        // Must use matchers for all arguments when using any matcher
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(2), eq(new byte[] { 0x02 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData2));

TEXT	foo(SB), DUPOK|NOSPLIT, $0

	ADDF	F0, F1, F2    // 002a31ee
	ADDD.EQ	F3, F4, F5    // 035b340e
	ADDF.NE	F0, F2        // 002a321e
	ADDD	F3, F5        // 035b35ee
	SUBF	F0, F1, F2    // 402a31ee
	SUBD.EQ	F3, F4, F5    // 435b340e
	SUBF.NE	F0, F2        // 402a321e
	SUBD	F3, F5        // 435b35ee
	MULF	F0, F1, F2    // 002a21ee
	MULD.EQ	F3, F4, F5    // 035b240e
	MULF.NE	F0, F2        // 002a221e

								[]clause.Expression{clause.Eq{clause.Column{Table: "profiles", Name: "email"}, clause.Column{Table: clause.CurrentTable, Name: "email"}}},
							},
						},
					},
				}, clause.From{
					Joins: []clause.Join{
						{
							Type:  clause.InnerJoin,
							Table: clause.Table{Name: "articles"},
							ON: clause.Where{

        doNothing().when(raf).write(any(byte[].class), anyInt(), anyInt());

        raf.writeBytes("hi");
        raf.writeChars("yo");

        verify(raf).write(any(byte[].class), eq(0), eq(2)); // bytes
        verify(raf).write(any(byte[].class), eq(0), eq(4)); // chars
    }

    @Test
    @DisplayName("writeUTF(): prefixes size and writes encoded bytes")
    void writeUTF_encodesAndPrefixes() throws Exception {

		stmt := gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}
		clauses := []clause.Interface{clause.Select{}, clause.From{}, clause.Where{Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})}}}

		for _, clause := range clauses {
			stmt.AddClause(clause)
		}

            return false;
        }

        DelegatingLocalArtifactRepository other = (DelegatingLocalArtifactRepository) obj;

        return eq(buildReactor, other.buildReactor)
                && eq(ideWorkspace, other.ideWorkspace)
                && eq(userLocalArtifactRepository, other.userLocalArtifactRepository);
    }

        when(nsc.getAllByName(eq("server"), eq(false))).thenReturn(new Address[] { addr });
        SmbResourceLocatorImpl workgroupLike = locator("smb://server/");
        // path is "/" -> triggers possibleNTDomainOrWorkgroup true
        when(nsc.getAllByName(eq("server"), eq(true))).thenReturn(new Address[] { addr });
        assertTrue(workgroupLike.isWorkgroup());

        assertArrayEquals(new byte[] { 9, 9 }, encOut);
        verify(enc, times(1)).encryptMessage(eq(new byte[] { 1, 2, 3 }), eq(99L));

        byte[] decOut = session.decryptMessage(new byte[] { 5 });
        assertArrayEquals(new byte[] { 7, 7 }, decOut);
        verify(enc, times(1)).decryptMessage(eq(new byte[] { 5 }));
    }

    @Test
    @DisplayName("getTransport returns acquired transport instance")