import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.stream.Stream;

import org.apache.maven.api.Lifecycle;

        // With default lmCompatibility=3, getUnicodeHash returns empty array for NTLMv2
        NtlmPasswordAuthentication auth = new NtlmPasswordAuthentication("DOMAIN", "user", "password");
        byte[] challenge = { 1, 2, 3, 4, 5, 6, 7, 8 };
        byte[] hash = auth.getUnicodeHash(challenge);
        assertNotNull(hash);
        // For lmCompatibility 3,4,5 (NTLMv2), returns empty array
        assertEquals(0, hash.length);
    }

import org.gradle.api.specs.Specs;
import org.gradle.api.tasks.Copy;
import org.gradle.api.tasks.TaskProvider;
import org.gradle.api.tasks.testing.Test;

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.function.Supplier;
import java.util.stream.Stream;

    /**
     * Get size of this structure
     *
     * @return size in bytes (16)
     */
    public static int size() {
        return 16; // 8 + 4 + 4
    }

    /**
     * Encode this structure to byte array
     *
     * @param dst destination buffer
     * @param dstIndex starting index
     * @return number of bytes written
     */
    public int encode(byte[] dst, int dstIndex) {

                        "type": "object",
                        "properties": {
                            "loc": {
                                "title": "Location",
                                "type": "array",
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                            },

   */

  /**
   * Ensures that {@code index} specifies a valid <i>element</i> in an array, list or string of size
   * {@code size}. An element index may range from zero, inclusive, to {@code size}, exclusive.
   *
   * @param index a user-supplied index identifying an element of an array, list or string
   * @param size the size of that array, list or string
   * @return the value of {@code index}

			}
		} else if rel := relationships.Relations[name]; rel != nil {
			if joined, nestedJoins := isJoined(name); joined {
				switch rv := db.Statement.ReflectValue; rv.Kind() {
				case reflect.Slice, reflect.Array:
					if rv.Len() > 0 {
						reflectValue := rel.FieldSchema.MakeSlice().Elem()
						for i := 0; i < rv.Len(); i++ {
							frv := rel.Field.ReflectValueOf(db.Statement.Context, rv.Index(i))

    assertTrue("addAll(n, containsNull) should return true", getList().addAll(0, containsNull));
    /*
     * We need (E) to force interpretation of null as the single element of a
     * varargs array, not the array itself
     */
    expectAdded(0, (E) null);
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)

        }
    }

    /**
     * Test encode with empty byte array
     *
     * @throws Exception
     */
    public void testEncode_EmptyArray() throws Exception {
        final String result = Base64Util.encode(new byte[0]);
        assertEquals("Empty array should return empty string", "", result);
    }

    /**
     * Test encode with null returns empty string
     *

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.smb;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

import org.bouncycastle.asn1.ASN1Encoding;
import org.bouncycastle.asn1.ASN1ObjectIdentifier;
import org.bouncycastle.asn1.ASN1OutputStream;
import org.bouncycastle.asn1.DERSequence;
import org.slf4j.Logger;