}
    } catch (e: Throwable) {
      if (KNOWN_FAILURES.contains(testData.toString())) {
        System.err.println("Ignoring known failure: $testData")
        e.printStackTrace()
      } else {
        throw e
      }
    }
  }

  private fun testHttpUrl(testData: WebPlatformUrlTestData) {
    val url =
      when (testData.base) {

    for (int i = 0; i < threadCount; i++) {
      executor.execute(() -> {
        try {
          drainQueue();
        } catch (Exception e) {
          e.printStackTrace();
        }
      });
    }
    executor.shutdown();
  }

  private void drainQueue() throws Exception {
    for (HttpUrl url; (url = queue.take()) != null; ) {
      if (!fetchedUrls.add(url)) {

            Thread.sleep(10);
            sink.writeUtf8(String.format(" * %s = %s\n", i, factor(i)));
          }
          sink.close();
        } catch (IOException | InterruptedException e) {
          e.printStackTrace();
        }
      }

      private String factor(int n) {
        for (int i = 2; i < n; i++) {
          int x = n / i;
          if (x * i == n) return factor(x) + " × " + i;
        }

     * int dot = name.indexOf('.');
     * if (dot == -1)
     * break;
     * name = name.substring(dot + 1);
     * }
     * } catch (NamingException ne) {
     * if (log.level > 1)
     * ne.printStackTrace(log);
     * }
     * 
     * throw uhe != null ? uhe : new UnknownHostException("invalid name");
     * }
     */

    Object addr;
    String calledName;


    /**

    }

    private void logError(String message, Exception e) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        e.printStackTrace(pw);
        String stackTrace = sw.toString();

        String fullMessage = message + "\n" + "Exception: "
                + e.getClass().getName() + "\n" + "Message: "

                dstIndex += b.length;
                dst[dstIndex++] = (byte)'\0';
            }
        } catch( UnsupportedEncodingException uee ) {
            if( log.level > 1 )
                uee.printStackTrace( log );
        }

        return dstIndex - start;
    }
    String readString( byte[] src, int srcIndex ) {
        return readString( src, srcIndex, 256, useUnicode );
    }

                    }

                    Thread.sleep(100);
                    t.interrupt();
                }
                catch ( InterruptedException e ) {
                    e.printStackTrace();
                }
            }
        });

        try {
            CIFSContext c = getContext();
            c = withTestNTLMCredentials(c);

                delete(*filesToCleanUp.toTypedArray())
            }
        } catch (e: Exception) {
            // https://github.com/gradle/gradle-private/issues/2983#issuecomment-596083202
            e.printStackTrace()
        }
    }

    private
    fun TestFilesCleanupProjectState.prepareReportForCiPublishing(reports: List<File>) {
        val projectPathName = projectPath.get().replace(':', '-')

            final Disposable disposable = disposables.removeLast();
            try {
                disposable.dispose();
            } catch (final Throwable t) {
                t.printStackTrace(); // must not use Logger.
            }
        }
        disposables.clear();
        Introspector.flushCaches();
    }

                    }
                } catch( UnsupportedEncodingException uee ) {
                    if( log.level > 1 )
                        uee.printStackTrace( log );
                }
                bufferIndex += len;
            } else {
                server.oemDomainName = new String();
            }
        } else {
            server.guid = new byte[16];