* License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs.pac;


import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;

import org.bouncycastle.asn1.*;


/**
 * 
 *
 */
public final class ASN1Util {

   *
   * @return byte read from input
   * @throws IOException if an error is encountered while reading
   * @throws EOFException if the end of file (EOF) is encountered.
   */
  private byte readAndCheckByte() throws IOException, EOFException {
    int b1 = in.read();

    if (-1 == b1) {
      throw new EOFException();
    }

    return (byte) b1;
  }

      val header = Buffer().writeUtf8(value(h))
      try {
        header.readChallengeHeader(result)
      } catch (e: EOFException) {
        Platform.get().log("Unable to parse challenge", Platform.WARN, e)
      }
    }
  }
  return result
}

@Throws(EOFException::class)
private fun Buffer.readChallengeHeader(result: MutableList<Challenge>) {
  var peek: String? = null

  while (true) {

    assertThrows(EOFException.class, () -> in.readUnsignedByte());
  }

  public void testReadUnsignedShort_eof() throws IOException {
    byte[] buf = {23};
    DataInput in = new LittleEndianDataInputStream(new ByteArrayInputStream(buf));
    assertThrows(EOFException.class, () -> in.readUnsignedShort());
  }

  @SuppressWarnings("DoNotCall")

    assertThrows(EOFException.class, () -> in.readUnsignedByte());
  }

  public void testReadUnsignedShort_eof() throws IOException {
    byte[] buf = {23};
    DataInput in = new LittleEndianDataInputStream(new ByteArrayInputStream(buf));
    assertThrows(EOFException.class, () -> in.readUnsignedShort());
  }

  @SuppressWarnings("DoNotCall")

 * limitations under the License.
 */
package okhttp3.internal.ws

import assertk.assertThat
import assertk.assertions.isEqualTo
import assertk.assertions.isLessThan
import java.io.EOFException
import kotlin.test.assertFailsWith
import okhttp3.TestUtil.fragmentBuffer
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.ByteString.Companion.encodeUtf8

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.logging.internal

import java.io.EOFException
import okio.Buffer

/**
 * Returns true if the body in question probably contains human readable text. Uses a small
 * sample of code points to detect unicode control characters commonly used in binary file

    data.write("8a0548656c".decodeHex()) // Length = 5, "Hel"
    assertFailsWith<EOFException> {
      clientReader.processNextFrame()
    }
  }

  @Test fun serverIncompleteMessageBodyThrows() {
    data.write("818537fa213d7f9f4d".decodeHex()) // Length = 5, "Hel"
    assertFailsWith<EOFException> {
      serverReader.processNextFrame()
    }
  }

        boundary = "simple boundary",
        source = Buffer().writeUtf8(multipart),
      )

    val part = parts.nextPart()!!
    assertFailsWith<EOFException> {
      assertThat(part.body.readUtf8()).isEqualTo("abcd\r\nefgh\r\n")
    }

    assertFailsWith<EOFException> {
      assertThat(parts.nextPart()).isNull()
    }
  }

  @Test fun `malformed headers`() {
    val multipart =
      """

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package okhttp3.dnsoverhttps

import java.io.EOFException
import java.net.InetAddress
import java.net.UnknownHostException
import okio.Buffer
import okio.ByteString
import okio.utf8Size

/**