case 'b':
            case 'c':
            case 'd':
            case 'e':
            case 'f':
                value += 10 + arr[ai] - 'a';
                break;
            default:
                throw new IllegalArgumentException(new String(arr, offset, length));
            }
            count++;
        }

        return value;
    }

                password = session.auth.getAnsiHash(session.transport.server.encryptionKey);
                passwordLength = password.length;
            } else if (DISABLE_PLAIN_TEXT_PASSWORDS) {
                throw new RuntimeException("Plain text passwords are disabled");
            } else {
                // plain text
                password = new byte[(session.auth.password.length() + 1) * 2];

        try {
            Field field = SmbComWrite.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            return field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException("Failed to access field " + fieldName, e);
        }
    }

    /**
     * Test that the constructor initializes all fields correctly
     */
    @Test
    public void testConstructor() {

        final Reader rd = new StringReader(inputStr);
        try (TokenStream stream = createTokenStream(rd)) {
            if (stream == null) {
                throw new IOException("Invalid tokenizer.");
            }
            stream.reset();

            int offset = 0;
            while (stream.incrementToken()) {

                out.write(buf, 0, len);
                amount += len;
            }
            out.flush();
            return amount;
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Copies the contents of a file input stream to an output stream.
     * <p>
     * Neither the file input stream nor the output stream is closed.

        TermQuery termQuery = new TermQuery(new Term("title", "test"));

        try {
            queryCommand.execute(queryContext, termQuery, 1.0f);
            fail("Should throw InvalidQueryException");
        } catch (InvalidQueryException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("Unknown q:"));
        }
    }

    @Test

   * FeatureSpecificTestSuiteBuilder.suppressing()}.
   */
  /*
   * TODO(cpovirk): or we could make HOLES_FORBIDDEN a feature. Or we could declare that
   * implementations are permitted to throw IAE if a hole is requested, and we could update
   * test*Hole to permit IAE. (But might this ignore genuine bugs?) But see the TODO above
   * testLower, which could make this all unnecessary
   */

      helper = new SafeAtomicHelper();
    } catch (Throwable reflectionFailure) { // sneaky checked exception
      // Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause
      // getDeclaredField to throw a NoSuchFieldException when the field is definitely there.
      // For these users fallback to a suboptimal implementation, based on synchronized. This will
      // be a definite performance hit to those users.

          urls.add(new URL("file", null, new File(entry).getAbsolutePath()));
        }
      } catch (MalformedURLException e) {
        throw new AssertionError("malformed class path entry: " + entry, e);
      }
    }
    return urls.build();
  }

        /**
         *
         */
        private static final long serialVersionUID = 1L;

        @Override
        public synchronized void load(final InputStream inStream) throws IOException {
            throw new IOException("load");
        }

    }

    /**
     * {@link org.codelibs.core.io.PropertiesUtil#load(Properties, String)}
     */
    @Test
    public void testLoadPropertiesPath() {