if (logger == null) {
            System.err.println(message);
            if (showStackTrace && e != null) {
                e.printStackTrace(System.err);
            }
            return;
        }
        if (showStackTrace) {
            logger.error(message, e);
        } else {
            logger.error(message);

                System.err.println("Missing: " + artifact);
            }
        }

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

                str = new String(src, srcIndex, len, SmbConstants.OEM_ENCODING);
            }
        } catch (final UnsupportedEncodingException uee) {
            if (LogStream.level > 1) {
                uee.printStackTrace(log);
            }
        }
        return str;
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override

     * @param e the exception that occurred
     */
    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: "

                }
            } catch (final SmbAuthException sae) {
                if (LogStream.level > 2) {
                    sae.printStackTrace(log);
                }
            } catch (final SmbException se) {
                if (LogStream.level > 2) {
                    se.printStackTrace(log);
                }
                if (se.getNtStatus() != NtStatus.NT_STATUS_UNSUCCESSFUL) {
                    throw se;

                String line;
                while ((line = reader.readLine()) != null) {
                    ps.println(line);
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                latch.countDown();
            }
        }).start();
        return os;
    }

   * wrapping it in an AssertionFailedError if necessary.
   */
  final void threadUnexpectedException(Throwable t) {
    threadRecordFailure(t);
    t.printStackTrace();
    if (t instanceof RuntimeException) {
      throw (RuntimeException) t;
    } else if (t instanceof Error) {
      throw (Error) t;
    } else {

    }

    @Override
    public void finalizeReferent() {
      references.remove(this);
      try {
        state.reset();
      } catch (Throwable t) {
        t.printStackTrace(System.err);
      }
    }
  }

  private static final class FbosByteSource extends ByteSource {
    final State state;

    FbosByteSource(State state) {
      this.state = state;
    }

                        }
                        successCount.incrementAndGet();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    endLatch.countDown();
                }
            });
        }

        // Start all threads simultaneously
        startLatch.countDown();

                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;

    /**