}

  /**
   * Drains the queue as {@linkplain #drain(BlockingQueue, Collection, int, Duration)}, but with a
   * different behavior in case it is interrupted while waiting. In that case, the operation will
   * continue as usual, and in the end the thread's interruption status will be set (no {@code
   * InterruptedException} is thrown).
   *
   * @param q the blocking queue to be drained

                        this.authMethod = "NTLM";
                        break;
                    }
                    if (currentAuthMethod.indexOf(' ') != 4) {
                        continue;
                    }
                    this.authMethod = "NTLM";
                    authorization = currentAuthMethod.substring(5).trim();
                    break;
                }

                    }
                    continue;
                }
                if (!isUrlCrawlable(paramMap, crawlRequest.getUrl())) {
                    continue;
                }
                counter++;
                final Map<String, Object> localDataMap =

        String[] components = path.split("[\\\\/]");

        for (String component : components) {
            if (component.isEmpty()) {
                continue; // Skip empty components (from double slashes)
            }

            // Check component length
            if (component.length() > maxComponentLength) {

                    .get());
            options.addOption(Option.builder(FAIL_AT_END)
                    .longOpt("fail-at-end")
                    .desc("Only fail the build afterwards; allow all non-impacted builds to continue")
                    .get());
            options.addOption(Option.builder(FAIL_NEVER)
                    .longOpt("fail-never")
                    .desc("NEVER fail the build, regardless of project result")

		{"foo", "\n\tnewline \t % $ & * ^ # @ \n", testData, false, true},
	}

	for i, testCase := range testCases {
		if testCase.ignoreIfWindows && runtime.GOOS == "windows" {
			continue
		}
		err := storage.AppendFile(t.Context(), testCase.volumeName, testCase.objectName, testCase.data)
		expectErr := (err != nil)

		if expectErr != testCase.expectErr {

        .Builder()
        .add100Continue()
        .build(),
    )
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .header("Expect", "100-continue")
        .post("abc".toRequestBody("text/plain".toMediaType()))
        .build()
    val call = client.newCallWithListener(request)
    call.execute()

	// this map, that's an error.
	mustFindInPolicy := make(map[string][]string, len(formValues))
	for key, values := range formValues {
		if keyInPolicyExceptions[key] || strings.HasPrefix(key, "X-Ignore-") {
			continue
		}
		mustFindInPolicy[key] = values
	}

	// Iterate over policy conditions and check them against received form fields
	for _, policy := range postPolicyForm.Conditions.Policies {

                if (line.length() == 0 || line.charAt(0) == '#') {
                    if (updater != null) {
                        updater.write(line);
                    }
                    continue; // ignore empty lines and comments
                }

                final String inputStrings = line;
                final String input = unescape(inputStrings);

                if (input.length() > 0) {

        streamId = 0,
        length = settings.size() * 6,
        type = TYPE_SETTINGS,
        flags = FLAG_NONE,
      )
      for (i in 0 until Settings.COUNT) {
        if (!settings.isSet(i)) continue
        sink.writeShort(i)
        sink.writeInt(settings[i])
      }
      sink.flush()
    }
  }

  /**
   * Send a connection-level ping to the peer. `ack` indicates this is a reply. The data in