i++;
                } else if (s.equalsIgnoreCase("WINS")) {
                    if (nbns == null) {
                        if (LogStream.level > 1) {
                            log.println("UniAddress resolveOrder specifies WINS however the "
                                    + "jcifs.smb1.netbios.wins property has not been set");
                        }
                        continue;

        mockResponse.clearReceived();

        // Verify that the method was called
        verify(mockResponse, times(1)).clearReceived();
    }

    @Test
    void testGetGrantedCredits() {
        // Simulate granted credits
        when(mockResponse.getGrantedCredits()).thenReturn(100);
        assertEquals(100, mockResponse.getGrantedCredits());

        // Verify the method was called

    assertEquals(0, ArbitraryInstances.get(FloatBuffer.class).capacity());
    assertEquals(0, ArbitraryInstances.get(DoubleBuffer.class).capacity());
    ArbitraryInstances.get(PrintStream.class).println("test");
    ArbitraryInstances.get(PrintWriter.class).println("test");
    assertNotNull(ArbitraryInstances.get(File.class));
    assertFreshInstanceReturned(
        ByteArrayOutputStream.class, OutputStream.class,

		} else {
			healingLogEvent(ctx, "Healing of drive '%s' is finished (healed: %d, skipped: %d).", disk, tracker.ItemsHealed, tracker.ItemsSkipped)
		}
	}
	if serverDebugLog {
		tracker.printTo(os.Stdout)
		fmt.Printf("\n")
	}

	if tracker.HealID == "" { // HealID was empty only before Feb 2023
		bugLogIf(ctx, tracker.delete(ctx))
		return nil
	}

	authCodeURL := oauth2Config.AuthCodeURL(state)
	// fmt.Printf("authcodeurl: %s\n", authCodeURL)

	var lastReq *http.Request
	checkRedirect := func(req *http.Request, via []*http.Request) error {
		// fmt.Printf("CheckRedirect:\n")
		// fmt.Printf("Upcoming: %s %s\n", req.Method, req.URL.String())
		// for i, c := range via {
		// 	fmt.Printf("Sofar %d: %s %s\n", i, c.Method, c.URL.String())
		// }

				if _, ok := field.TagSettings["EMBEDDED"]; ok || !fieldStruct.Anonymous {
					ef.EmbeddedBindNames = append([]string{fieldStruct.Name}, ef.EmbeddedBindNames...)
				}
				// index is negative means is pointer
				if field.FieldType.Kind() == reflect.Struct {
					ef.StructField.Index = append([]int{fieldStruct.Index[0]}, ef.StructField.Index...)
				} else {

        assertNull(pdis.readFiletime());
    }

    @Test
    public void testReadUnicodeString() throws IOException, PACDecodingException {
        // length=4, maxLength=4, pointer=0x1234
        byte[] data = new byte[] { 0x04, 0x00, 0x04, 0x00, 0x34, 0x12, 0x00, 0x00 };
        PacDataInputStream pdis = createInputStream(data);
        PacUnicodeString str = pdis.readUnicodeString();

    // loader, even if it is not visible to the loader of the Resources class.

    File tempFile = createTempFile();
    PrintWriter writer = new PrintWriter(tempFile, "UTF-8");
    writer.println("rud a chur ar an méar fhada");
    writer.close();

    // First check that we can't find it without setting the context loader.
    // This is a sanity check that the test doesn't spuriously pass because

    }

    private void printErrors(ArtifactResolutionResult result) {
        if (result.hasMissingArtifacts()) {
            for (Artifact artifact : result.getMissingArtifacts()) {
                System.err.println("Missing: " + artifact);
            }
        }

        if (result.hasExceptions()) {
            for (Exception e : result.getExceptions()) {
                e.printStackTrace();
            }
        }

// The returned string is heap-allocated, and caller should call free() on it.
//
// Do not return const char*, because some foreign language binding
// (e.g. swift) cannot then call free() on the returned pointer.
TF_CAPI_EXPORT extern char* TF_FunctionDebugString(TF_Function* func,
                                                   size_t* len);

// On success, dequeues a tensor from a TF-managed FifoQueue given by