blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 7 332 | content_id stringlengths 40 40 | detected_licenses listlengths 0 50 | license_type stringclasses 2 values | repo_name stringlengths 7 115 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 557 values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 5.85k 684M ⌀ | star_events_count int64 0 77.7k | fork_events_count int64 0 48k | gha_license_id stringclasses 17 values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 82 values | src_encoding stringclasses 28 values | language stringclasses 1 value | is_vendor bool 1 class | is_generated bool 2 classes | length_bytes int64 7 5.41M | extension stringclasses 11 values | content stringlengths 7 5.41M | authors listlengths 1 1 | author stringlengths 0 161 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
5bfa5359f87de4d06d38a58934cf461b867eee7e | a4a2aa2d39ca40874fa250c3552bba9e10c65cb2 | /Labs/Lab3/app/build/generated/source/buildConfig/debug/com/example/android/navdrawerexperiment/BuildConfig.java | 73718988c1b1cd5f4341a6fe0fbbcb11836ec157 | [
"Apache-2.0"
] | permissive | Aldoreh46/COMP4200 | 418c311f680785179f2c0d392b538453c22c0bbc | dc9bf760852614f160910a759a40ce39e0235de6 | refs/heads/main | 2023-03-11T00:48:51.391486 | 2021-03-02T01:42:09 | 2021-03-02T01:42:09 | 331,457,021 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 443 | java | /**
* Automatically generated file. DO NOT MODIFY
*/
package com.example.android.navdrawerexperiment;
public final class BuildConfig {
public static final boolean DEBUG = Boolean.parseBoolean("true");
public static final String APPLICATION_ID = "com.example.android.navdrawerexperiment";
public static final String BUILD_TYPE = "debug";
public static final int VERSION_CODE = 1;
public static final String VERSION_NAME = "1.0";
}
| [
"37591733+Aldoreh46@users.noreply.github.com"
] | 37591733+Aldoreh46@users.noreply.github.com |
92d4d9f35ff8ca8e62749d4871b4e5a3a5f4155d | 3457d78ae3dd2bce827f6b927d601eb8856e2567 | /src/main/java/coursera/bio/iii/ManhattanTourist.java | d5bf680274a64864d1e17da10ef2a99248b86182 | [] | no_license | fejesa/coursera-bioinfo | 9db85fae4575eb8a6a04a3e64c7be438266f43ec | d4351f8cc5ca624f2bf9671865a5978e16a8b503 | refs/heads/master | 2020-03-25T17:35:12.160100 | 2018-08-08T08:41:23 | 2018-08-08T08:41:23 | 143,984,889 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 520 | java | package coursera.bio.iii;
public class ManhattanTourist {
public static int longestPath(int n, int m, int[][] down, int[][] right) {
int[][] s = new int[n + 1][m + 1];
for (int i = 1; i <= n; ++i) {
s[i][0] = s[i - 1][0] + down[i - 1][0];
}
for (int j = 1; j <= m; ++j) {
s[0][j] = s[0][j - 1] + right[0][j - 1];
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
s[i][j] = Integer.max(s[i - 1][j] + down[i - 1][j], s[i][j - 1] + right[i][j - 1]);
}
}
return s[n][m];
}
} | [
"andras.fejes@omixon.com"
] | andras.fejes@omixon.com |
9fc0330ede58baf326b63e6d9a1cf72553444cac | bd695cd51b58ee1e179b618d916384deb81a1cd9 | /login/src/com/internousdev/login/action/LoginAction.java | 1cbdb12860151066bb816b518da2ab38d548cee1 | [] | no_license | hijiri00018/test | 0959d5fcf70c1e0cf2faab08f5fe4d9e73e690f3 | f83907053eee2bc4bf71d53545b4b2c5e5112c24 | refs/heads/master | 2020-04-11T20:56:14.704761 | 2018-12-27T06:31:44 | 2018-12-27T06:31:44 | 162,088,939 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 793 | java | package com.internousdev.login.action;
import java.sql.SQLException;
import com.internousdev.login.dao.LoginDAO;
import com.internousdev.login.dto.LoginDTO;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction extends ActionSupport{
private String name;
private String password;
public String execute()throws SQLException{
String ret = ERROR;
LoginDAO dao =new LoginDAO();
LoginDTO dto =new LoginDTO();
dto=dao.select(name, password);
if(name.equals(dto.getName())){
if(password.equals(dto.getPassword())){
ret=SUCCESS;
}
}
return ret;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public String getPassword(){
return password;
}
public void setPassword(String password){
this.password=password;
}
}
| [
"hijiri19930423@gmail.com"
] | hijiri19930423@gmail.com |
5d5a1d56826fd1644c8366b6a31c19aa00a159ae | a132b5f4f6c8b9619321eebfadc42422e6b1cdfc | /src/main/java/com/minh/contacts/models/requests/LoginRequest.java | f768d089e83f882b06722940e44a50284bdffc3a | [] | no_license | huynhngocminh2511/Contacts_API | 12d624342696762a67a504ad4969ee9ce1163d92 | cc8f44bc09652d5a13746b9b51c013c7143d6289 | refs/heads/master | 2020-07-24T19:17:38.903666 | 2019-09-13T16:21:33 | 2019-09-13T16:31:49 | 208,021,368 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 417 | java | package com.minh.contacts.models.requests;
import lombok.Data;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Pattern;
@Data
public class LoginRequest {
@NotBlank(message = "Email is mandatory")
@Email
private String email;
@NotBlank(message = "Password is mandatory")
private String password;
}
| [
"huynhngocminh2511@gmail.com"
] | huynhngocminh2511@gmail.com |
5b44f832826ef0aaedabe72002ee8422f2fc433a | ae024bc52ad3a7e97a8d7bc9aef83194e587dde7 | /app/src/main/java/com/bwie/unit1111/tuyi/mvp/TianjiaPresenter.java | f8f841421b58b664dd4cdd576d5a1193e73da5a3 | [] | no_license | songjiawei123123/zhoukao3 | 2bee76b943074ab769ac78479754024387381181 | 6d5544dfbf9079af7616093e41f42db67c99a687 | refs/heads/master | 2020-03-21T08:55:14.242576 | 2018-06-23T05:25:15 | 2018-06-23T05:25:15 | 138,373,815 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 707 | java | package com.bwie.unit1111.tuyi.mvp;
import okhttp3.ResponseBody;
public class TianjiaPresenter implements TianjiaZiP {
private TianjiaModel sousuoModel;
private TianjiaView sousuoView;
public TianjiaPresenter(){
sousuoModel = new TianjiaModel(this);
}
public void attachView(TianjiaView iDuanZiView){
this.sousuoView = iDuanZiView;
}
public void dettachView(){
if (sousuoView != null){
sousuoView = null;
}
}
public void getData(String url,String key){
sousuoModel.getData(url,key);
}
@Override
public void onSuccess(ResponseBody responseBody) {
sousuoView.onSuccess(responseBody);
}
} | [
"319762657@qq.com"
] | 319762657@qq.com |
4bd622c8823b5662c31716c325a0ef1a82df0878 | 0602e018366d762d102e3d0c1fa52160fcfa6a35 | /com/dotrow/mail/server/MailServerFilter.java | 9714238ed730b021aaa68f16ea370678866bf545 | [] | no_license | sergioceron/drmailserver | 619a03df98389d02b8658a0ca22f0073437011e1 | 41396f4ab3671b99a303b2d4d1c1145285cfb610 | refs/heads/master | 2016-09-05T10:07:25.426366 | 2012-07-10T03:36:27 | 2012-07-10T03:36:27 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,602 | java | /*
* Copyright DotRow.com (c) 2012.
*
* Este programa se distribuye segun la licencia GPL v.2 o posteriores y no
* tiene garantias de ningun tipo. Puede obtener una copia de la licencia GPL o
* ponerse en contacto con la Free Software Foundation en http://www.gnu.org
*/
package com.dotrow.mail.server;
/*
* MailFilter.java
*
* Created on 19 de junio de 2006, 18:11
*/
import com.dotrow.mail.server.util.NSLookup;
import java.sql.ResultSet;
import java.sql.Statement;
/**
* Filtra los correos spam o por ip
* @author Sergio Ceron Figueroa
*/
public class MailServerFilter implements DatabaseConnection {
private static MailServerFilter _instance = null;
/** Configuraciones del servidor */
private static Settings set = Settings.getInstance();
/** Instancia activa del logger */
private Logger log = Logger.getInstance();
/** Asentamiento de la base de datos */
private static Statement st = null;
/** Crea una nueva instancia */
private MailServerFilter() {}
/**
* Regresa la instancia activa de MailServerFilter o crea una nueva si no existe
* @return una intancia de la clase MailServerFilter
*/
final static public MailServerFilter getInstance(){
return _instance != null ? _instance : new MailServerFilter();
}
/**
* Verifica si el filtro por ip esta activo
* @return si el filtro esta activo
* <I>true</I> si esta activo
* <I>alse</I> si esta deshabilitado
*/
protected boolean enabled(){
Boolean en = Boolean.valueOf( set.getStrKey( "MailServerFilter.enabled" ) );
return en.booleanValue();
}
/**
* Verifica si la ip tiene un nombre de resolucion inversa, asi se determina si la ip pertenece a algun dominio
* @return si se permite que la ip envie correo
* <I>true</I> si si coincide la ip con el dominio
* <I>true</I> si no coincide la ip con el dominio
* @param ip la ip para verificar con el dominio
* @param domain el dominio que debe coincidir con la ip en la resolucion inversa
*/
protected boolean allowReciveMail( String ip, String domain ){
NSLookup nslu = NSLookup.getInstance();
if( nslu.reverseLookup( ip ).indexOf( domain ) != 0 )
return true;
return false;
}
/**
* Filtra el correo que ha sido enviado con la base de datos de spam
* @return si el correo es aceptado y no esta en la base de datos
* <I>true</I> si el correo es aceptado
* <I>false</I> si el correo es spam
* @param from el dominio de donde proviene el correo
* @param to el usuario a quien va dirigido
*/
protected boolean filterMailToSpam( String from, String to ){
boolean allow = true;
if( UserHandler.newInstance().isFilterEnabled( to ) ){
try{
ResultSet rs = st.executeQuery( "SELECT * FROM dr_deny_mails WHERE deny_mails_user = '" + to + "' and deny_mails_mail = '" + from + "'" );
if( rs.next() )
allow = false;
}catch(Exception e){
log.debug(e, Logger.Level.ERROR);
}
}
return allow;
}
/**
* Actualiza el asentamiento de la base de datos por medio de la interface
* @param st el asentamiento de la base de datos
*/
public void setStatement(java.sql.Statement st) {
MailServerFilter.st = st;
}
}
| [
"sceronf@gmail.com"
] | sceronf@gmail.com |
2610a620a1de9943b8e524912ee058fd4c85b212 | 005a36608a5022625cacfc2f0bc6fddac5bfc014 | /src/servelet/Example1ServeletWithShowBookName.java | 27d32a646b14cba8b13e71c271c0453e96abd192 | [] | no_license | swordjoinmagic/JSPLesson | 783d2ba30c78d33b8f4e0faa2a2cb04bd6794168 | 111447ebe4a91499f28e8a5b4177b95619f8d319 | refs/heads/master | 2020-03-17T03:45:19.760091 | 2018-05-15T13:13:57 | 2018-05-15T13:13:57 | 133,249,362 | 0 | 0 | null | null | null | null | GB18030 | Java | false | false | 1,603 | java | package servelet;
import java.io.IOException;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import ado.CommonDatabase;
import ado.CommonDatabaseWithConnectionPool;
import ado.CommonDatabaseWithSimple;
import ado.CommonDatabaseWithSingle;
import javabean.Book;
@WebServlet("/showBookName")
public class Example1ServeletWithShowBookName extends HttpServlet{
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// TODO Auto-generated method stub
// 传统数据库连接模式
// CommonDatabaseWithSimple cdws = new CommonDatabaseWithSimple();
// 单例模式连接数据库
// CommonDatabaseWithSingle cdws = CommonDatabaseWithSingle.getAdo();
// 数据库连接池模式连接数据库
CommonDatabaseWithConnectionPool cwcp = new CommonDatabaseWithConnectionPool();
List<Book>list = cwcp.commonQuery("select * from bookes", Book.class);
// 第四步,将存放数据的数据结构存入requests中
req.setAttribute("bookList", list);
// 第五步，寻找对应视图，分发请求
RequestDispatcher dispatcher = req.getRequestDispatcher("/example/example1ShowBookName.jsp");
dispatcher.forward(req, resp);
}
}
| [
"2483787753@qq.com"
] | 2483787753@qq.com |
dec185b6a4408e8fe6de0870a24c414f013a1904 | 2bcef5111c09e27e9b2e5363452ad70f498af2da | /apps/skry-fi/src/com/department13/skryfi/SortingNetworkObject.java | 6b32e7f66707e1f1d66713af01d9c16aeca15b7a | [
"MIT"
] | permissive | robisen1/AndroidWifiCracker | d13fbc2dff7228fc9d81d4dcb0d20d008761d3d8 | 10c966829237c48159d847b6c54889915415e260 | refs/heads/master | 2016-08-05T16:11:35.984209 | 2014-08-03T16:57:25 | 2014-08-03T16:57:25 | 22,592,329 | 27 | 7 | null | null | null | null | UTF-8 | Java | false | false | 146 | java | package com.department13.skryfi;
import java.util.Comparator;
public abstract class SortingNetworkObject implements Comparator<Network>
{
}
| [
"ian@starnes.us"
] | ian@starnes.us |
7e2a42fc01e8c148506af040bb2b854a57884bb0 | 5e06358c0d97a9e8b19c03cb104a2d3e38b76831 | /gui-replayer-core/src/main/java/edu/umd/cs/guitar/replayer/monitor/TestStepEndEventArgs.java | b404664fe329985e32e52515e144448a3cfdd6e1 | [] | no_license | bryantrobbins/guitar2 | 30672f86ec61848e6882c1323215b8ab79a61d9e | c3c21b7c9d6aeaad27d531d9a57c19bcb8d523ef | refs/heads/master | 2021-03-22T05:09:13.313703 | 2015-11-27T03:19:09 | 2015-11-27T03:19:09 | 22,456,034 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 888 | java | package edu.umd.cs.guitar.replayer.monitor;
import edu.umd.cs.guitar.model.data.ComponentType;
import edu.umd.cs.guitar.model.data.GUIType;
import edu.umd.cs.guitar.model.data.StepType;
/**
* A wrapper of test step data Info about a testcase step event.
*
* @deprecated Use a subclass of {@link GTestStepEventArgs} instead
* @author <a href="mailto:baonn@cs.umd.edu"> Bao Nguyen </a>
*
*/
@Deprecated
public class TestStepEndEventArgs extends GTestStepEventArgs {
public ComponentType component;
GUIType window;
public ComponentType getComponent() {
return component;
}
public GUIType getWindow() {
return window;
}
/**
* @param step
* @param component
* @param window
*/
public TestStepEndEventArgs(StepType step, ComponentType component, GUIType window) {
super(step);
this.component = component;
this.window = window;
}
}
| [
"bryantrobbins@gmail.com"
] | bryantrobbins@gmail.com |
d7baf0fb5f8ce99db811e58c4a390593f8328c11 | 56024e45290167ff8944fe11595ee0512c458eda | /proj1b/Deque.java | 7389e0df8c83fd2e969e1c7275e3f3314f9fd211 | [] | no_license | ybsun3/cs61b | 74bd8f0385e0a929db7f6f6f47248c944458516a | 58a79f9df23048ee055e36ed73e59bb1b1c313f2 | refs/heads/master | 2023-06-14T04:07:55.964922 | 2021-07-16T08:35:56 | 2021-07-16T08:35:56 | 386,561,462 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 208 | java | public interface Deque<T> {
void addFirst(T item);
void addLast(T item);
T removeFirst();
T removeLast();
boolean isEmpty();
int size();
void printDeque();
T get(int index);
}
| [
"yibosun9@gmail.com"
] | yibosun9@gmail.com |
538682e532d9c408c36e6e649f1230578718b2d8 | 78d52a708b0a4fef6db6343686fcb52471b7a2b5 | /src/main/java/com/ahea/calculator/function/CrossCheckCalculator.java | b62a930a4c5394eb7d277ef4430fc05857ef4e38 | [] | no_license | devahea/2018hackerton-calculator | 001227e0db1c619e001b9fdf959ac055127342fc | 55d0ac15b01f9b57a183c7b6f14dc262cdf23423 | refs/heads/master | 2020-03-28T08:16:36.959779 | 2018-09-09T11:32:33 | 2018-09-09T11:32:33 | 147,955,265 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,528 | java | package com.ahea.calculator.function;
import com.ahea.calculator.CalculatorService;
/*
대각선에 숫자가 있으면 처리 (5번)
*/
public class CrossCheckCalculator implements Runnable {
private static final int ROOM_TYPE = -1;
private static final int POOL_TYPE = -2;
@Override
public void run() {
//ongoingSource를 통해서 정답을 도출한후 다시 변경해준다.
CalculatorService.ongoingSource = calculate();
}
private int[][] calculate() {
int[][] myMap = CalculatorService.ongoingSource;
int width = myMap[0].length;
int height = myMap.length;
for(int i = 0 ; i < myMap.length; i++) {
for(int j = 0 ; j < myMap[0].length; j++) {
//대각선 오른쪽 아래 체크
// indexCheck
if(!(i+1 == height) && !(j + 1 == width)){
if(myMap[i][j] > 0 && myMap[i+1][j+1] > 0) {
myMap[i+1][j] = POOL_TYPE;
myMap[i][j+1] = POOL_TYPE;
}
}
//대각선 왼쪽 아래 체크
if(!(i+1 == height) && !(j == 0)){
if(myMap[i][j] > 0 && myMap[i+1][j-1] > 0) {
myMap[i][j-1] = POOL_TYPE;
myMap[i+1][j] = POOL_TYPE;
}
}
}
}
//문제푸는 로직을 수행후 변경된 값을 리턴한다.
return myMap;
}
}
| [
"shtjdgus1090@naver.com"
] | shtjdgus1090@naver.com |
fb79ed897e4b4efc456b28266fa46c6c87dd6135 | 866c05f4612a018bd09a6c1cb8a6b41c8691ecc8 | /app/src/main/java/pulau/com/pulauterunik/PulauHuvahendhoo.java | 120b10eda0e6db74426192f222a57dfc42df6929 | [] | no_license | 151610237-smkassalaambandung/PulauTerunik | cae625ce7a20d74ea1b60710e934ed070b57fdf6 | 9b5f37a44bacf2a8b2d3ddfb46ce2aaf08664d13 | refs/heads/master | 2021-01-06T20:40:29.077388 | 2017-08-08T12:33:09 | 2017-08-08T12:33:09 | 99,543,973 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 786 | java | package pulau.com.pulauterunik;
import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class PulauHuvahendhoo extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_pulau_huvahendhoo);
Button home = (Button) findViewById(R.id.button);
home.setOnClickListener(new View.OnClickListener(){
public void onClick(View bebek){
Intent myIntent = new
Intent(bebek.getContext(), Utama.class);
startActivityForResult(myIntent, 0);
}
});
}
}
| [
"151610237@smkasssalaambandung.sch.id"
] | 151610237@smkasssalaambandung.sch.id |
b20b7935c9cb7a050eb7e8302085a59940f78093 | ae007c2eff5b8a1e9694836e568f8b116bb83aab | /src/main/java/ca/sheridancollege/pate1431/repositories/ResturantRepository.java | 4f088f11fce6ac7292906cccbb9aa084dab3ae97 | [] | no_license | pate1431/Resturant-Reservation | dc87206b6dfcf69f981f4948540aeccc2146b9fd | 10b1e4a89a2f8315aba2882ceb8fd5d1deae6973 | refs/heads/master | 2023-08-07T23:55:12.632944 | 2021-09-15T17:59:06 | 2021-09-15T17:59:06 | 406,873,338 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 248 | java | package ca.sheridancollege.pate1431.repositories;
import org.springframework.data.jpa.repository.JpaRepository;
import ca.sheridancollege.pate1431.beans.Resturant;
public interface ResturantRepository extends JpaRepository<Resturant, Long> {
}
| [
"devsnehalpatel@gmail.com"
] | devsnehalpatel@gmail.com |
1a03323dedec26439961d68b76653d94f01fa719 | ae5eb1a38b4d22c82dfd67c86db73592094edc4b | /project62/src/main/java/org/gradle/test/performance/largejavamultiproject/project62/p313/Production6264.java | 163815748572f3a5a71d8a789bfea7db27018ef0 | [] | no_license | big-guy/largeJavaMultiProject | 405cc7f55301e1fd87cee5878a165ec5d4a071aa | 1cd6a3f9c59e9b13dffa35ad27d911114f253c33 | refs/heads/main | 2023-03-17T10:59:53.226128 | 2021-03-04T01:01:39 | 2021-03-04T01:01:39 | 344,307,977 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,959 | java | package org.gradle.test.performance.largejavamultiproject.project62.p313;
public class Production6264 {
private Production6261 property0;
public Production6261 getProperty0() {
return property0;
}
public void setProperty0(Production6261 value) {
property0 = value;
}
private Production6262 property1;
public Production6262 getProperty1() {
return property1;
}
public void setProperty1(Production6262 value) {
property1 = value;
}
private Production6263 property2;
public Production6263 getProperty2() {
return property2;
}
public void setProperty2(Production6263 value) {
property2 = value;
}
private String property3;
public String getProperty3() {
return property3;
}
public void setProperty3(String value) {
property3 = value;
}
private String property4;
public String getProperty4() {
return property4;
}
public void setProperty4(String value) {
property4 = value;
}
private String property5;
public String getProperty5() {
return property5;
}
public void setProperty5(String value) {
property5 = value;
}
private String property6;
public String getProperty6() {
return property6;
}
public void setProperty6(String value) {
property6 = value;
}
private String property7;
public String getProperty7() {
return property7;
}
public void setProperty7(String value) {
property7 = value;
}
private String property8;
public String getProperty8() {
return property8;
}
public void setProperty8(String value) {
property8 = value;
}
private String property9;
public String getProperty9() {
return property9;
}
public void setProperty9(String value) {
property9 = value;
}
} | [
"sterling.greene@gmail.com"
] | sterling.greene@gmail.com |
7db249e640e9b75412b10d63fb63a0450fa4c534 | 7a33f49b47f57273d9245d5f93ba23aba093bdfd | /FoodOrderingApp-api/src/main/java/com/upgrad/FoodOrderingApp/api/controller/PaymentController.java | c6690cfa55e45459a024694240a4150bda3fcc59 | [] | no_license | anushapatilb/FoodOrderingApp-Backend | 782262cd66794a62c44aaf7ad65278800ee744d4 | f96a1d2aec791aa724a23baa7abeebb1a62e4356 | refs/heads/master | 2023-05-31T22:59:36.220745 | 2021-07-04T13:49:12 | 2021-07-04T13:49:12 | 382,857,905 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,717 | java | package com.upgrad.FoodOrderingApp.api.controller;
import com.upgrad.FoodOrderingApp.service.businness.PaymentService;
import com.upgrad.FoodOrderingApp.service.entity.PaymentEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.upgrad.FoodOrderingApp.api.model.PaymentListResponse;
import com.upgrad.FoodOrderingApp.api.model.PaymentResponse;
import java.util.List;
import java.util.UUID;
@RestController
public class PaymentController {
@Autowired
private PaymentService paymentService;
//Lists all available payment methods
//No API input
@RequestMapping(value = "/payment", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
public ResponseEntity<PaymentListResponse> getPaymentResponse() {
List<PaymentEntity> paymentEntityList = paymentService.getAllPaymentMethods();
PaymentListResponse paymentListResponse = new PaymentListResponse();
for(PaymentEntity payment : paymentEntityList){
PaymentResponse paymentResponse = new PaymentResponse();
paymentResponse.setId(UUID.fromString(payment.getUuid()));
paymentResponse.setPaymentName(payment.getPaymentName());
paymentListResponse.addPaymentMethodsItem(paymentResponse);
}
return new ResponseEntity<PaymentListResponse>(paymentListResponse, HttpStatus.OK);
}
}
| [
"anusha.patil156@gmail.com"
] | anusha.patil156@gmail.com |
ac5b0ba243cb17a8d6f6c611adc01332a0186b1c | e688cef62cb07a27e89b387c1d50ec889b2b931a | /src/Xls_Reader.java | 0b8c3523adc1057b12ff78cce7c8ba5776b4693d | [] | no_license | Anupam28/MyRepository | 8a311e4105c9227ba8c27208faccc60d0d586565 | 75624d4f8f5ebb7b9729436d8ecff3127233f1a0 | refs/heads/master | 2021-09-01T16:35:07.121359 | 2017-12-27T23:05:26 | 2017-12-27T23:05:26 | 115,564,209 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 12,731 | java |
import org.apache.poi.hssf.usermodel.HSSFCellStyle;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFHyperlink;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.xssf.usermodel.*;
import java.io.*;
import java.util.Calendar;
public class Xls_Reader {
public static String filename = System.getProperty("user.dir")+"\\src\\config\\testcases\\TestData.xlsx";
public String path;
public FileInputStream fis = null;
public FileOutputStream fileOut =null;
private XSSFWorkbook workbook = null;
private XSSFSheet sheet = null;
private XSSFRow row =null;
private XSSFCell cell = null;
public Xls_Reader(String path) {
this.path=path;
try {
fis = new FileInputStream(path);
workbook = new XSSFWorkbook(fis);
sheet = workbook.getSheetAt(0);
fis.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// returns the row count in a sheet
public int getRowCount(String sheetName){
int index = workbook.getSheetIndex(sheetName);
if(index==-1)
return 0;
else{
sheet = workbook.getSheetAt(index);
int number=sheet.getLastRowNum()+1;
return number;
}
}
// returns the data from a cell
public String getCellData(String sheetName,String colName,int rowNum){
try{
if(rowNum <=0)
return "";
int index = workbook.getSheetIndex(sheetName);
int col_Num=-1;
if(index==-1)
return "";
sheet = workbook.getSheetAt(index);
row=sheet.getRow(0);
for(int i=0;i<row.getLastCellNum();i++){
//System.out.println(row.getCell(i).getStringCellValue().trim());
if(row.getCell(i).getStringCellValue().trim().equals(colName.trim()))
col_Num=i;
}
if(col_Num==-1)
return "";
sheet = workbook.getSheetAt(index);
row = sheet.getRow(rowNum-1);
if(row==null)
return "";
cell = row.getCell(col_Num);
if(cell==null)
return "";
//System.out.println(cell.getCellType());
if(cell.getCellType()==Cell.CELL_TYPE_STRING)
return cell.getStringCellValue();
else if(cell.getCellType()==Cell.CELL_TYPE_NUMERIC || cell.getCellType()==Cell.CELL_TYPE_FORMULA ){
String cellText = String.valueOf(cell.getNumericCellValue());
if (HSSFDateUtil.isCellDateFormatted(cell)) {
// format in form of M/D/YY
double d = cell.getNumericCellValue();
Calendar cal =Calendar.getInstance();
cal.setTime(HSSFDateUtil.getJavaDate(d));
cellText =
(String.valueOf(cal.get(Calendar.YEAR))).substring(2);
cellText = cal.get(Calendar.DAY_OF_MONTH) + "/" +
cal.get(Calendar.MONTH)+1 + "/" +
cellText;
//System.out.println(cellText);
}
return cellText;
}else if(cell.getCellType()==Cell.CELL_TYPE_BLANK)
return "";
else
return String.valueOf(cell.getBooleanCellValue());
}
catch(Exception e){
e.printStackTrace();
return "row "+rowNum+" or column "+colName +" does not exist in xls";
}
}
// returns the data from a cell
public String getCellData(String sheetName,int colNum,int rowNum){
try{
if(rowNum <=0)
return "";
int index = workbook.getSheetIndex(sheetName);
if(index==-1)
return "";
sheet = workbook.getSheetAt(index);
row = sheet.getRow(rowNum-1);
if(row==null)
return "";
cell = row.getCell(colNum);
if(cell==null)
return "";
if(cell.getCellType()==Cell.CELL_TYPE_STRING)
return cell.getStringCellValue();
else if(cell.getCellType()==Cell.CELL_TYPE_NUMERIC || cell.getCellType()==Cell.CELL_TYPE_FORMULA ){
String cellText = String.valueOf(cell.getNumericCellValue());
if (HSSFDateUtil.isCellDateFormatted(cell)) {
// format in form of M/D/YY
double d = cell.getNumericCellValue();
Calendar cal =Calendar.getInstance();
cal.setTime(HSSFDateUtil.getJavaDate(d));
cellText =
(String.valueOf(cal.get(Calendar.YEAR))).substring(2);
cellText = cal.get(Calendar.MONTH)+1 + "/" +
cal.get(Calendar.DAY_OF_MONTH) + "/" +
cellText;
// System.out.println(cellText);
}
return cellText;
}else if(cell.getCellType()==Cell.CELL_TYPE_BLANK)
return "";
else
return String.valueOf(cell.getBooleanCellValue());
}
catch(Exception e){
e.printStackTrace();
return "row "+rowNum+" or column "+colNum +" does not exist in xls";
}
}
// returns true if data is set successfully else false
public boolean setCellData(String sheetName,String colName,int rowNum, String data){
try{
fis = new FileInputStream(path);
workbook = new XSSFWorkbook(fis);
if(rowNum<=0)
return false;
int index = workbook.getSheetIndex(sheetName);
int colNum=-1;
if(index==-1)
return false;
sheet = workbook.getSheetAt(index);
row=sheet.getRow(0);
for(int i=0;i<row.getLastCellNum();i++){
//System.out.println(row.getCell(i).getStringCellValue().trim());
if(row.getCell(i).getStringCellValue().trim().equals(colName))
colNum=i;
}
if(colNum==-1)
return false;
sheet.autoSizeColumn(colNum);
row = sheet.getRow(rowNum-1);
if (row == null)
row = sheet.createRow(rowNum-1);
cell = row.getCell(colNum);
if (cell == null)
cell = row.createCell(colNum);
// cell style
//CellStyle cs = workbook.createCellStyle();
//cs.setWrapText(true);
//cell.setCellStyle(cs);
cell.setCellValue(data);
fileOut = new FileOutputStream(path);
workbook.write(fileOut);
fileOut.close();
}
catch(Exception e){
e.printStackTrace();
return false;
}
return true;
}
// returns true if data is set successfully else false
public boolean setCellData(String sheetName,String colName,int rowNum, String data,String url){
//System.out.println("setCellData setCellData******************");
try{
fis = new FileInputStream(path);
workbook = new XSSFWorkbook(fis);
if(rowNum<=0)
return false;
int index = workbook.getSheetIndex(sheetName);
int colNum=-1;
if(index==-1)
return false;
sheet = workbook.getSheetAt(index);
//System.out.println("A");
row=sheet.getRow(0);
for(int i=0;i<row.getLastCellNum();i++){
//System.out.println(row.getCell(i).getStringCellValue().trim());
if(row.getCell(i).getStringCellValue().trim().equalsIgnoreCase(colName))
colNum=i;
}
if(colNum==-1)
return false;
sheet.autoSizeColumn(colNum); //ashish
row = sheet.getRow(rowNum-1);
if (row == null)
row = sheet.createRow(rowNum-1);
cell = row.getCell(colNum);
if (cell == null)
cell = row.createCell(colNum);
cell.setCellValue(data);
XSSFCreationHelper createHelper = workbook.getCreationHelper();
//cell style for hyperlinks
//by default hypelrinks are blue and underlined
CellStyle hlink_style = workbook.createCellStyle();
XSSFFont hlink_font = workbook.createFont();
hlink_font.setUnderline(XSSFFont.U_SINGLE);
hlink_font.setColor(IndexedColors.BLUE.getIndex());
hlink_style.setFont(hlink_font);
//hlink_style.setWrapText(true);
XSSFHyperlink link = createHelper.createHyperlink(XSSFHyperlink.LINK_FILE);
link.setAddress(url);
cell.setHyperlink(link);
cell.setCellStyle(hlink_style);
fileOut = new FileOutputStream(path);
workbook.write(fileOut);
fileOut.close();
}
catch(Exception e){
e.printStackTrace();
return false;
}
return true;
}
// returns true if sheet is created successfully else false
public boolean addSheet(String sheetname){
FileOutputStream fileOut;
try {
workbook.createSheet(sheetname);
fileOut = new FileOutputStream(path);
workbook.write(fileOut);
fileOut.close();
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
// returns true if sheet is removed successfully else false if sheet does not exist
public boolean removeSheet(String sheetName){
int index = workbook.getSheetIndex(sheetName);
if(index==-1)
return false;
FileOutputStream fileOut;
try {
workbook.removeSheetAt(index);
fileOut = new FileOutputStream(path);
workbook.write(fileOut);
fileOut.close();
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
// returns true if column is created successfully
public boolean addColumn(String sheetName,String colName){
//System.out.println("**************addColumn*********************");
try{
fis = new FileInputStream(path);
workbook = new XSSFWorkbook(fis);
int index = workbook.getSheetIndex(sheetName);
if(index==-1)
return false;
XSSFCellStyle style = workbook.createCellStyle();
style.setFillForegroundColor(HSSFColor.GREY_40_PERCENT.index);
style.setFillPattern(HSSFCellStyle.SOLID_FOREGROUND);
sheet=workbook.getSheetAt(index);
row = sheet.getRow(0);
if (row == null)
row = sheet.createRow(0);
//cell = row.getCell();
//if (cell == null)
//System.out.println(row.getLastCellNum());
if(row.getLastCellNum() == -1)
cell = row.createCell(0);
else
cell = row.createCell(row.getLastCellNum());
cell.setCellValue(colName);
cell.setCellStyle(style);
fileOut = new FileOutputStream(path);
workbook.write(fileOut);
fileOut.close();
}catch(Exception e){
e.printStackTrace();
return false;
}
return true;
}
// removes a column and all the contents
public boolean removeColumn(String sheetName, int colNum) {
try{
if(!isSheetExist(sheetName))
return false;
fis = new FileInputStream(path);
workbook = new XSSFWorkbook(fis);
sheet=workbook.getSheet(sheetName);
XSSFCellStyle style = workbook.createCellStyle();
style.setFillForegroundColor(HSSFColor.GREY_40_PERCENT.index);
XSSFCreationHelper createHelper = workbook.getCreationHelper();
style.setFillPattern(HSSFCellStyle.NO_FILL);
for(int i =0;i<getRowCount(sheetName);i++){
row=sheet.getRow(i);
if(row!=null){
cell=row.getCell(colNum);
if(cell!=null){
cell.setCellStyle(style);
row.removeCell(cell);
}
}
}
fileOut = new FileOutputStream(path);
workbook.write(fileOut);
fileOut.close();
}
catch(Exception e){
e.printStackTrace();
return false;
}
return true;
}
// find whether sheets exists
public boolean isSheetExist(String sheetName){
int index = workbook.getSheetIndex(sheetName);
if(index==-1){
index=workbook.getSheetIndex(sheetName.toUpperCase());
if(index==-1)
return false;
else
return true;
}
else
return true;
}
// returns number of columns in a sheet
public int getColumnCount(String sheetName){
// check if sheet exists
if(!isSheetExist(sheetName))
return -1;
sheet = workbook.getSheet(sheetName);
row = sheet.getRow(0);
if(row==null)
return -1;
return row.getLastCellNum();
}
//String sheetName, String testCaseName,String keyword ,String URL,String message
public boolean addHyperLink(String sheetName,String screenShotColName,String testCaseName,int index,String url,String message){
//System.out.println("ADDING addHyperLink******************");
url=url.replace('\\', '/');
if(!isSheetExist(sheetName))
return false;
sheet = workbook.getSheet(sheetName);
for(int i=2;i<=getRowCount(sheetName);i++){
if(getCellData(sheetName, 0, i).equalsIgnoreCase(testCaseName)){
//System.out.println("**caught "+(i+index));
setCellData(sheetName, screenShotColName, i+index, message,url);
break;
}
}
return true;
}
public int getCellRowNum(String sheetName,String colName,String cellValue){
for(int i=2;i<=getRowCount(sheetName);i++){
if(getCellData(sheetName,colName , i).equalsIgnoreCase(cellValue)){
return i;
}
}
return -1;
}
// to run this on stand alone
public static void main(String arg[]) throws IOException{
//System.out.println(filename);
Xls_Reader datatable = null;
datatable = new Xls_Reader("H:\\Student_Selenium_Workspaces\\Framework_Weekend\\src\\Framework_XL_Files\\Controller.xlsx");
for(int col=0 ;col< datatable.getColumnCount("TC5"); col++){
System.out.println(datatable.getCellData("TC5", col, 1));
}
}
}
| [
"Anupam.Agrawal3@cox.com"
] | Anupam.Agrawal3@cox.com |
ca961def9d6c186476ed506fa043b2b44e20f9e5 | 30ec9b7b339d96bd256e405322f9fe5c3216312f | /src/Obe/SVM/svm_toy.java | c62f94a28d5aad18aa855026a05e6e8b340d81ed | [] | no_license | Observerspy/UserStableMatching | ca5973d7922d8550e04c7a82e89fe90f2615b7f7 | b3012e69bb5aaaff6e5fa40f7642e28d68142c89 | refs/heads/master | 2020-07-25T19:12:45.544173 | 2016-11-15T03:47:30 | 2016-11-15T03:47:30 | 73,772,462 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 12,287 | java | package Obe.SVM;
import libsvm.*;
import java.applet.*;
import java.awt.*;
import java.util.*;
import java.awt.event.*;
import java.io.*;
public class svm_toy extends Applet {
static final String DEFAULT_PARAM="-t 2 -c 100";
int XLEN;
int YLEN;
// off-screen buffer
Image buffer;
Graphics buffer_gc;
// pre-allocated colors
final static Color colors[] =
{
new Color(0,0,0),
new Color(0,120,120),
new Color(120,120,0),
new Color(120,0,120),
new Color(0,200,200),
new Color(200,200,0),
new Color(200,0,200)
};
class point {
point(double x, double y, byte value)
{
this.x = x;
this.y = y;
this.value = value;
}
double x, y;
byte value;
}
Vector<point> point_list = new Vector<point>();
byte current_value = 1;
public void init()
{
setSize(getSize());
final Button button_change = new Button("Change");
Button button_run = new Button("Run");
Button button_clear = new Button("Clear");
Button button_save = new Button("Save");
Button button_load = new Button("Load");
final TextField input_line = new TextField(DEFAULT_PARAM);
BorderLayout layout = new BorderLayout();
this.setLayout(layout);
Panel p = new Panel();
GridBagLayout gridbag = new GridBagLayout();
p.setLayout(gridbag);
GridBagConstraints c = new GridBagConstraints();
c.fill = GridBagConstraints.HORIZONTAL;
c.weightx = 1;
c.gridwidth = 1;
gridbag.setConstraints(button_change,c);
gridbag.setConstraints(button_run,c);
gridbag.setConstraints(button_clear,c);
gridbag.setConstraints(button_save,c);
gridbag.setConstraints(button_load,c);
c.weightx = 5;
c.gridwidth = 5;
gridbag.setConstraints(input_line,c);
button_change.setBackground(colors[current_value]);
p.add(button_change);
p.add(button_run);
p.add(button_clear);
p.add(button_save);
p.add(button_load);
p.add(input_line);
this.add(p,BorderLayout.SOUTH);
button_change.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)
{ button_change_clicked(); button_change.setBackground(colors[current_value]); }});
button_run.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)
{ button_run_clicked(input_line.getText()); }});
button_clear.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)
{ button_clear_clicked(); }});
button_save.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)
{ button_save_clicked(input_line.getText()); }});
button_load.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)
{ button_load_clicked(); }});
input_line.addActionListener(new ActionListener()
{ public void actionPerformed (ActionEvent e)
{ button_run_clicked(input_line.getText()); }});
this.enableEvents(AWTEvent.MOUSE_EVENT_MASK);
}
void draw_point(point p)
{
Color c = colors[p.value+3];
Graphics window_gc = getGraphics();
buffer_gc.setColor(c);
buffer_gc.fillRect((int)(p.x*XLEN),(int)(p.y*YLEN),4,4);
window_gc.setColor(c);
window_gc.fillRect((int)(p.x*XLEN),(int)(p.y*YLEN),4,4);
}
void clear_all()
{
point_list.removeAllElements();
if(buffer != null)
{
buffer_gc.setColor(colors[0]);
buffer_gc.fillRect(0,0,XLEN,YLEN);
}
repaint();
}
void draw_all_points()
{
int n = point_list.size();
for(int i=0;i<n;i++)
draw_point(point_list.elementAt(i));
}
void button_change_clicked()
{
++current_value;
if(current_value > 3) current_value = 1;
}
private static double atof(String s)
{
return Double.valueOf(s).doubleValue();
}
private static int atoi(String s)
{
return Integer.parseInt(s);
}
void button_run_clicked(String args)
{
// guard
if(point_list.isEmpty()) return;
svm_parameter param = new svm_parameter();
// default values
param.svm_type = svm_parameter.C_SVC;
param.kernel_type = svm_parameter.RBF;
param.degree = 3;
param.gamma = 0;
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 40;
param.C = 1;
param.eps = 1e-3;
param.p = 0.1;
param.shrinking = 1;
param.probability = 0;
param.nr_weight = 0;
param.weight_label = new int[0];
param.weight = new double[0];
// parse options
StringTokenizer st = new StringTokenizer(args);
String[] argv = new String[st.countTokens()];
for(int i=0;i<argv.length;i++)
argv[i] = st.nextToken();
for(int i=0;i<argv.length;i++)
{
if(argv[i].charAt(0) != '-') break;
if(++i>=argv.length)
{
System.err.print("unknown option\n");
break;
}
switch(argv[i-1].charAt(1))
{
case 's':
param.svm_type = atoi(argv[i]);
break;
case 't':
param.kernel_type = atoi(argv[i]);
break;
case 'd':
param.degree = atoi(argv[i]);
break;
case 'g':
param.gamma = atof(argv[i]);
break;
case 'r':
param.coef0 = atof(argv[i]);
break;
case 'n':
param.nu = atof(argv[i]);
break;
case 'm':
param.cache_size = atof(argv[i]);
break;
case 'c':
param.C = atof(argv[i]);
break;
case 'e':
param.eps = atof(argv[i]);
break;
case 'p':
param.p = atof(argv[i]);
break;
case 'h':
param.shrinking = atoi(argv[i]);
break;
case 'b':
param.probability = atoi(argv[i]);
break;
case 'w':
++param.nr_weight;
{
int[] old = param.weight_label;
param.weight_label = new int[param.nr_weight];
System.arraycopy(old,0,param.weight_label,0,param.nr_weight-1);
}
{
double[] old = param.weight;
param.weight = new double[param.nr_weight];
System.arraycopy(old,0,param.weight,0,param.nr_weight-1);
}
param.weight_label[param.nr_weight-1] = atoi(argv[i-1].substring(2));
param.weight[param.nr_weight-1] = atof(argv[i]);
break;
default:
System.err.print("unknown option\n");
}
}
// build problem
svm_problem prob = new svm_problem();
prob.l = point_list.size();
prob.y = new double[prob.l];
if(param.kernel_type == svm_parameter.PRECOMPUTED)
{
}
else if(param.svm_type == svm_parameter.EPSILON_SVR ||
param.svm_type == svm_parameter.NU_SVR)
{
if(param.gamma == 0) param.gamma = 1;
prob.x = new svm_node[prob.l][1];
for(int i=0;i<prob.l;i++)
{
point p = point_list.elementAt(i);
prob.x[i][0] = new svm_node();
prob.x[i][0].index = 1;
prob.x[i][0].value = p.x;
prob.y[i] = p.y;
}
// build model & classify
svm_model model = svm.svm_train(prob, param);
svm_node[] x = new svm_node[1];
x[0] = new svm_node();
x[0].index = 1;
int[] j = new int[XLEN];
Graphics window_gc = getGraphics();
for (int i = 0; i < XLEN; i++)
{
x[0].value = (double) i / XLEN;
j[i] = (int)(YLEN*svm.svm_predict(model, x));
}
buffer_gc.setColor(colors[0]);
buffer_gc.drawLine(0,0,0,YLEN-1);
window_gc.setColor(colors[0]);
window_gc.drawLine(0,0,0,YLEN-1);
int p = (int)(param.p * YLEN);
for(int i=1;i<XLEN;i++)
{
buffer_gc.setColor(colors[0]);
buffer_gc.drawLine(i,0,i,YLEN-1);
window_gc.setColor(colors[0]);
window_gc.drawLine(i,0,i,YLEN-1);
buffer_gc.setColor(colors[5]);
window_gc.setColor(colors[5]);
buffer_gc.drawLine(i-1,j[i-1],i,j[i]);
window_gc.drawLine(i-1,j[i-1],i,j[i]);
if(param.svm_type == svm_parameter.EPSILON_SVR)
{
buffer_gc.setColor(colors[2]);
window_gc.setColor(colors[2]);
buffer_gc.drawLine(i-1,j[i-1]+p,i,j[i]+p);
window_gc.drawLine(i-1,j[i-1]+p,i,j[i]+p);
buffer_gc.setColor(colors[2]);
window_gc.setColor(colors[2]);
buffer_gc.drawLine(i-1,j[i-1]-p,i,j[i]-p);
window_gc.drawLine(i-1,j[i-1]-p,i,j[i]-p);
}
}
}
else
{
if(param.gamma == 0) param.gamma = 0.5;
prob.x = new svm_node [prob.l][2];
for(int i=0;i<prob.l;i++)
{
point p = point_list.elementAt(i);
prob.x[i][0] = new svm_node();
prob.x[i][0].index = 1;
prob.x[i][0].value = p.x;
prob.x[i][1] = new svm_node();
prob.x[i][1].index = 2;
prob.x[i][1].value = p.y;
prob.y[i] = p.value;
}
// build model & classify
svm_model model = svm.svm_train(prob, param);
svm_node[] x = new svm_node[2];
x[0] = new svm_node();
x[1] = new svm_node();
x[0].index = 1;
x[1].index = 2;
Graphics window_gc = getGraphics();
for (int i = 0; i < XLEN; i++)
for (int j = 0; j < YLEN ; j++) {
x[0].value = (double) i / XLEN;
x[1].value = (double) j / YLEN;
double d = svm.svm_predict(model, x);
if (param.svm_type == svm_parameter.ONE_CLASS && d<0) d=2;
buffer_gc.setColor(colors[(int)d]);
window_gc.setColor(colors[(int)d]);
buffer_gc.drawLine(i,j,i,j);
window_gc.drawLine(i,j,i,j);
}
}
draw_all_points();
}
void button_clear_clicked()
{
clear_all();
}
void button_save_clicked(String args)
{
FileDialog dialog = new FileDialog(new Frame(),"Save",FileDialog.SAVE);
dialog.setVisible(true);
String filename = dialog.getDirectory() + dialog.getFile();
if (filename == null) return;
try {
DataOutputStream fp = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename)));
int svm_type = svm_parameter.C_SVC;
int svm_type_idx = args.indexOf("-s ");
if(svm_type_idx != -1)
{
StringTokenizer svm_str_st = new StringTokenizer(args.substring(svm_type_idx+2).trim());
svm_type = atoi(svm_str_st.nextToken());
}
int n = point_list.size();
if(svm_type == svm_parameter.EPSILON_SVR || svm_type == svm_parameter.NU_SVR)
{
for(int i=0;i<n;i++)
{
point p = point_list.elementAt(i);
fp.writeBytes(p.y+" 1:"+p.x+"\n");
}
}
else
{
for(int i=0;i<n;i++)
{
point p = point_list.elementAt(i);
fp.writeBytes(p.value+" 1:"+p.x+" 2:"+p.y+"\n");
}
}
fp.close();
} catch (IOException e) { System.err.print(e); }
}
void button_load_clicked()
{
FileDialog dialog = new FileDialog(new Frame(),"Load",FileDialog.LOAD);
dialog.setVisible(true);
String filename = dialog.getDirectory() + dialog.getFile();
if (filename == null) return;
clear_all();
try {
BufferedReader fp = new BufferedReader(new FileReader(filename));
String line;
while((line = fp.readLine()) != null)
{
StringTokenizer st = new StringTokenizer(line," \t\n\r\f:");
if(st.countTokens() == 5)
{
byte value = (byte)atoi(st.nextToken());
st.nextToken();
double x = atof(st.nextToken());
st.nextToken();
double y = atof(st.nextToken());
point_list.addElement(new point(x,y,value));
}
else if(st.countTokens() == 3)
{
double y = atof(st.nextToken());
st.nextToken();
double x = atof(st.nextToken());
point_list.addElement(new point(x,y,current_value));
}else
break;
}
fp.close();
} catch (IOException e) { System.err.print(e); }
draw_all_points();
}
protected void processMouseEvent(MouseEvent e)
{
if(e.getID() == MouseEvent.MOUSE_PRESSED)
{
if(e.getX() >= XLEN || e.getY() >= YLEN) return;
point p = new point((double)e.getX()/XLEN,
(double)e.getY()/YLEN,
current_value);
point_list.addElement(p);
draw_point(p);
}
}
public void paint(Graphics g)
{
// create buffer first time
if(buffer == null) {
buffer = this.createImage(XLEN,YLEN);
buffer_gc = buffer.getGraphics();
buffer_gc.setColor(colors[0]);
buffer_gc.fillRect(0,0,XLEN,YLEN);
}
g.drawImage(buffer,0,0,this);
}
public Dimension getPreferredSize() { return new Dimension(XLEN,YLEN+50); }
public void setSize(Dimension d) { setSize(d.width,d.height); }
public void setSize(int w,int h) {
super.setSize(w,h);
XLEN = w;
YLEN = h-50;
clear_all();
}
public static void main(String[] argv)
{
new AppletFrame("svm_toy",new svm_toy(),500,500+50);
}
}
class AppletFrame extends Frame {
AppletFrame(String title, Applet applet, int width, int height)
{
super(title);
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
applet.init();
applet.setSize(width,height);
applet.start();
this.add(applet);
this.pack();
this.setVisible(true);
}
}
| [
"Observerspy@hotmail.com"
] | Observerspy@hotmail.com |
5c7aa0dd4a5d068146841b646fbaa1cb931d3cab | 9b9709b955f2791c004be525e465d3b50adbf057 | /src/main/java/org/hospitality/app/repository/utility/AilmentRepository.java | aabf545342e4e3e94d6041b624b14436a14498e0 | [] | no_license | neil00797/hospitalityApp | 143a837ab6751ece883da7e98c75fa917167be86 | 475d85842c52fe37435106923d497dffffdfdc37 | refs/heads/master | 2023-01-20T04:20:20.731109 | 2020-12-03T08:53:58 | 2020-12-03T08:53:58 | 276,371,002 | 0 | 33 | null | 2020-12-02T14:55:40 | 2020-07-01T12:24:37 | Java | UTF-8 | Java | false | false | 379 | java | package org.hospitality.app.repository.utility;
import org.hospitality.app.entity.utility.Ailment;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
/*
author: @SenzoMkupa
date: 31-08-2020
*/
import java.util.Set;
@Repository
public interface AilmentRepository extends JpaRepository<Ailment, String> {
}
| [
"neiljohnson00797@gmail.com"
] | neiljohnson00797@gmail.com |
21a29229bea145afa86effb6109133f3f62ff715 | f6a458207fb03fb729ca9c8b10e9f67998590264 | /config-server/src/test/java/com/mall/configserver/ConfigserverApplicationTests.java | 32336bb3f30dcc0c0fe3a270ede5fab4db7bf44e | [] | no_license | alexgit2018/mall-clound | 947a7ae82d8a32826011dbcc71b6b4b8d4a6da74 | 0a3ad09ee3fbe6e1ef4e4a4c98da35b4c5c96545 | refs/heads/master | 2023-07-03T11:18:02.906823 | 2021-08-08T15:24:00 | 2021-08-08T15:24:00 | 389,650,675 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 228 | java | package com.mall.configserver;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class ConfigserverApplicationTests {
@Test
void contextLoads() {
}
}
| [
"114698176@qq.com"
] | 114698176@qq.com |
27ba260f5277082a9f13733e339ca0ce15303737 | 63d5d7d42df838e9cbfed48bf44c3f29b135f75a | /CoreJavaPractice/src/main/java/com/maven/BasicPrograms/PatternA5.java | 3f67b3a3292a9f95f87fc53da6406b26582e0fa5 | [] | no_license | Swethaalapati/CompleteJavaPractice | a8b8fa11d964342cc0b4840cdbd2e9c8b85f64ce | e8a94f3de944e038dbbdd621fcf05de1ca52d749 | refs/heads/main | 2023-08-28T03:56:07.263178 | 2021-11-01T11:20:20 | 2021-11-01T11:20:20 | 394,008,513 | 0 | 0 | null | 2021-11-01T11:20:21 | 2021-08-08T16:09:27 | Java | UTF-8 | Java | false | false | 416 | java | package com.maven.BasicPrograms;
import java.util.Scanner;
public class PatternA5 {
public static void main(String args[])
{
Scanner s = new Scanner(System.in);
System.out.println("enter n value");
int n = s.nextInt();
for(int i = 0; i < n; i++)
{
int ascii = 65;
for(int j = 0; j < n-i; j++)
{
System.out.print((char)ascii);
ascii++;
}
System.out.println();
}
}
}
| [
"swethaalapati402@gmail.com"
] | swethaalapati402@gmail.com |
63938e5d0a11b1595b532f4c942c1f7de39b12fd | 68fdd71428dc0599d6e5c29665d69286b403dc64 | /app/src/main/java/com/example/mygooglemap/Steps.java | 8e4a333eac713e810e912164142ad8920b16a22a | [] | no_license | vipjoker/MyGoogleMap | 336d36cf840e0ef92f051bacb68c2d37e586d57d | 2ee0bfad69fa737551653be2947fc201317c3f85 | refs/heads/master | 2016-09-06T11:49:00.891070 | 2014-10-26T17:43:24 | 2014-10-26T17:43:24 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,586 | java | package com.example.mygooglemap;
public class Steps {
private String distance ;
private String duration;
private String htmlInstruction;
private double startLocationLat;
private double startLocationLng;
private double endLocationLat;
private double endLocationLng;
public String getDistance() {
return distance;
}
public void setDistance(String distance) {
this.distance = distance;
}
public String getDuration() {
return duration;
}
public void setDuration(String duration) {
this.duration = duration;
}
public String getHtmlInstruction() {
return htmlInstruction;
}
public void setHtmlInstruction(String htmlInstruction) {
this.htmlInstruction = htmlInstruction;
}
public double getStartLocationLat() {
return startLocationLat;
}
public void setStartLocationLat(double startLocationLat) {
this.startLocationLat = startLocationLat;
}
public double getStartLocationLng() {
return startLocationLng;
}
public void setStartLocationLng(double startLocationLng) {
this.startLocationLng = startLocationLng;
}
public double getEndLocationLat() {
return endLocationLat;
}
public void setEndLocationLat(double endLocationLat) {
this.endLocationLat = endLocationLat;
}
public double getEndLocationLng() {
return endLocationLng;
}
public void setEndLocationLng(double endLocationLng) {
this.endLocationLng = endLocationLng;
}
}
| [
"tajcig@ya.ru"
] | tajcig@ya.ru |
c364cb1f1570979302ea09c00cbc7f5acf5e8e72 | b881b5d9ec6dcf2c8107b63eb4959cffd0a5a416 | /src/Income.java | 7810ad5e1bea3d9b61851c5c8dc2a005083d0394 | [] | no_license | JessikaRisberg/personalBudget | e31c532dfdc61d658e6370759ecd9a0295fd83de | 8cd5186cf11b66423948064ffa0e558804dfb930 | refs/heads/master | 2023-09-01T12:26:04.561271 | 2021-10-27T18:34:29 | 2021-10-27T18:34:29 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 406 | java | public class Income {
int sallary;
int other;
public void Income(int inSallary, int inOther) {
this.sallary = inSallary;
this.other = inOther;
}
public int getSallary(){ return sallary;}
public void setSallary(int sallary) { this.sallary = sallary; }
public int getOther() { return other; }
public void setOther(int other) { this.other = other; }
}
| [
"33091640+JessikaRisberg@users.noreply.github.com"
] | 33091640+JessikaRisberg@users.noreply.github.com |
2376a18a77cbf0ad1e1301695bffc466bd830769 | e46242d7d4c9422deb6bc45fccda4d786f9cddc9 | /producer/src/main/java/com/pyda/producer/SimpleEvent.java | 41c1a3251ff19bc737491591ce9e5b928a25ed05 | [
"MIT"
] | permissive | KPyda/kafka-stream-sample | 60963ce925df8343e874ef0040358d15acbba4ac | d5d15b3439a526d5f32f509496bcf305870638a5 | refs/heads/master | 2020-11-24T16:24:37.590745 | 2019-12-15T20:10:51 | 2019-12-15T20:10:51 | 228,243,841 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 408 | java | package com.pyda.producer;
import lombok.Value;
import java.time.LocalDateTime;
@Value(staticConstructor = "of")
class SimpleEvent {
private final String id;
private final Long clientId;
private final String username;
private final LocalDateTime time;
private final String firstName;
private final String lastName;
private final String phone;
private final String email;
}
| [
"jakub.pyda@upaid.pl"
] | jakub.pyda@upaid.pl |
db4a33c85fe3ab53413848d9ba84e82092589b28 | f2d1bcb13e4015dbda274cbb8e4d15db70624856 | /src/main/java/com/handmark/pulltorefresh/library/PullToRefreshScrollView.java | eae5400ce0972d9426363e5d49ca0946a6e6d53f | [] | no_license | roydang/AndroidArchetype_library | 56beb0551aa48e92c1f8be8c6b6b31c4881324f9 | 6269afc6f1672e90f647e245fb1e6ee36c92c5dd | refs/heads/master | 2016-09-06T02:48:01.257587 | 2013-03-13T08:51:34 | 2013-03-13T08:51:34 | 7,955,001 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 3,438 | java | /*******************************************************************************
* Copyright 2011, 2012 Chris Banes.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.handmark.pulltorefresh.library;
import m2.android.archetype.example.AndroidArchetype_library.R;
import android.annotation.TargetApi;
import android.content.Context;
import android.os.Build.VERSION;
import android.os.Build.VERSION_CODES;
import android.util.AttributeSet;
import android.view.View;
import android.widget.ScrollView;
public class PullToRefreshScrollView extends PullToRefreshBase<ScrollView> {
public PullToRefreshScrollView(Context context) {
super(context);
}
public PullToRefreshScrollView(Context context, AttributeSet attrs) {
super(context, attrs);
}
public PullToRefreshScrollView(Context context, Mode mode) {
super(context, mode);
}
public PullToRefreshScrollView(Context context, Mode mode, AnimationStyle style) {
super(context, mode, style);
}
@Override
public final Orientation getPullToRefreshScrollDirection() {
return Orientation.VERTICAL;
}
@Override
protected ScrollView createRefreshableView(Context context, AttributeSet attrs) {
ScrollView scrollView;
if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {
scrollView = new InternalScrollViewSDK9(context, attrs);
} else {
scrollView = new ScrollView(context, attrs);
}
scrollView.setId(R.id.scrollview);
return scrollView;
}
@Override
protected boolean isReadyForPullStart() {
return mRefreshableView.getScrollY() == 0;
}
@Override
protected boolean isReadyForPullEnd() {
View scrollViewChild = mRefreshableView.getChildAt(0);
if (null != scrollViewChild) {
return mRefreshableView.getScrollY() >= (scrollViewChild.getHeight() - getHeight());
}
return false;
}
@TargetApi(9)
final class InternalScrollViewSDK9 extends ScrollView {
public InternalScrollViewSDK9(Context context, AttributeSet attrs) {
super(context, attrs);
}
@Override
protected boolean overScrollBy(int deltaX, int deltaY, int scrollX, int scrollY, int scrollRangeX,
int scrollRangeY, int maxOverScrollX, int maxOverScrollY, boolean isTouchEvent) {
final boolean returnValue = super.overScrollBy(deltaX, deltaY, scrollX, scrollY, scrollRangeX,
scrollRangeY, maxOverScrollX, maxOverScrollY, isTouchEvent);
// Does all of the hard work...
OverscrollHelper.overScrollBy(PullToRefreshScrollView.this, deltaX, scrollX, deltaY, scrollY,
getScrollRange(), isTouchEvent);
return returnValue;
}
/**
* Taken from the AOSP ScrollView source
*/
private int getScrollRange() {
int scrollRange = 0;
if (getChildCount() > 0) {
View child = getChildAt(0);
scrollRange = Math.max(0, child.getHeight() - (getHeight() - getPaddingBottom() - getPaddingTop()));
}
return scrollRange;
}
}
}
| [
"hyongsoon.choi@nhn.com"
] | hyongsoon.choi@nhn.com |
7e0e10fad3193f87dc72ef3fa8d4b2c8dcfff93d | 97193b8aa46ae8217b1b358bab42a045a425fc25 | /archives_ws_client/com/ymsino/water/service/archives/user/GetCount.java | eb0d34645eb151bc9102767143e50435623828ab | [
"Apache-2.0"
] | permissive | xcjava/ymWaterWeb | faf393c03944b856cab21cc75bc3293c4ac2ac91 | f39aef6b9f4232acad6a4853b1129762a4666fac | refs/heads/master | 2021-01-19T09:49:50.660603 | 2014-11-13T17:04:55 | 2014-11-13T17:04:55 | 17,908,343 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 1,366 | java | package com.ymsino.water.service.archives.user;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;
/**
* <p>
* Java class for getCount complex type.
*
* <p>
* The following schema fragment specifies the expected content contained within
* this class.
*
* <pre>
* <complexType name="getCount">
* <complexContent>
* <restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
* <sequence>
* <element name="queryParam" type="{http://api.service.archives.esb.ymsino.com/}queryParam" minOccurs="0"/>
* </sequence>
* </restriction>
* </complexContent>
* </complexType>
* </pre>
*
*
*/
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "getCount", propOrder = { "queryParam" })
public class GetCount {
protected QueryParam queryParam;
/**
* Gets the value of the queryParam property.
*
* @return possible object is {@link QueryParam }
*
*/
public QueryParam getQueryParam() {
return queryParam;
}
/**
* Sets the value of the queryParam property.
*
* @param value
* allowed object is {@link QueryParam }
*
*/
public void setQueryParam(QueryParam value) {
this.queryParam = value;
}
}
| [
"xuyongbin2010@gmail.com"
] | xuyongbin2010@gmail.com |
fb0d9e5e8d2bcc391c773bb11fbb5b0166ae756e | 18cfb24c4914acd5747e533e88ce7f3a52eee036 | /src/main/jdk8/java/io/IOException.java | 581e6d15d130615e3b8511537267e55d33f0c3be | [] | no_license | douguohai/jdk8-code | f0498e451ec9099e4208b7030904e1b4388af7c5 | c8466ed96556bfd28cbb46e588d6497ff12415a0 | refs/heads/master | 2022-12-19T03:10:16.879386 | 2020-09-30T05:43:20 | 2020-09-30T05:43:20 | 273,399,965 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,678 | java | /*
* Copyright (c) 1994, 2006, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package java.io;
/**
* Signals that an I/O exception of some sort has occurred. This
* class is the general class of exceptions produced by failed or
* interrupted I/O operations.
*
* @author unascribed
* @see java.io.InputStream
* @see java.io.OutputStream
* @since JDK1.0
*/
public
class IOException extends Exception {
static final long serialVersionUID = 7818375828146090155L;
/**
* Constructs an {@code IOException} with {@code null}
* as its error detail message.
*/
public IOException() {
super();
}
/**
* Constructs an {@code IOException} with the specified detail message.
*
* @param message
* The detail message (which is saved for later retrieval
* by the {@link #getMessage()} method)
*/
public IOException(String message) {
super(message);
}
/**
* Constructs an {@code IOException} with the specified detail message
* and cause.
*
* <p> Note that the detail message associated with {@code cause} is
* <i>not</i> automatically incorporated into this exception's detail
* message.
*
* @param message
* The detail message (which is saved for later retrieval
* by the {@link #getMessage()} method)
*
* @param cause
* The cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is permitted,
* and indicates that the cause is nonexistent or unknown.)
*
* @since 1.6
*/
public IOException(String message, Throwable cause) {
super(message, cause);
}
/**
* Constructs an {@code IOException} with the specified cause and a
* detail message of {@code (cause==null ? null : cause.toString())}
* (which typically contains the class and detail message of {@code cause}).
* This constructor is useful for IO exceptions that are little more
* than wrappers for other throwables.
*
* @param cause
* The cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A null value is permitted,
* and indicates that the cause is nonexistent or unknown.)
*
* @since 1.6
*/
public IOException(Throwable cause) {
super(cause);
}
}
| [
"douguohai@163.com"
] | douguohai@163.com |
603d201048784a41145fb48556be51c4bb78ccaa | 99b5f5b99ce1fae32d06e7dd0b5ef11d4aba94d6 | /Week03/day3/Farm/src/Animal.java | f2fbb1b152735a47f7d6a039620114e22b146575 | [] | no_license | green-fox-academy/adambota | 129651117638bcb589e82a7686d2340b7d994de1 | a07be0f9df68b35c0d594101e45e392c6b320863 | refs/heads/master | 2020-03-24T23:48:36.631322 | 2019-06-01T19:36:16 | 2019-06-01T19:36:16 | 143,155,131 | 1 | 1 | null | null | null | null | UTF-8 | Java | false | false | 325 | java | public class Animal {
int hunger;
int thirst;
public Animal() {
this.hunger = 50;
this.thirst = 50;
}
public void eat() {
this.hunger--;
}
public void drink() {
this.thirst--;
}
public void play() {
this.hunger++;
this.thirst++;
}
}
| [
"adambota@gmail.com"
] | adambota@gmail.com |
86c8819f5d49e1874151cb41bf9f1f3278606550 | 6f10f784bf5ff201c5aadbb01b3bc6dd07599f7d | /app/src/main/java/me/synology/wookoo/shuttle_tracker_driver/GPSTestActivity.java | a33b84bc99219b851eadb431deaeb0fddf5c2030 | [] | no_license | wookoo/shuttle-tracker-driver | 2bd37586635067fc68f238461aed731b3ab208f1 | a12733b8af34258e4e1eae10d590639442fe06e4 | refs/heads/main | 2023-09-04T05:43:21.880920 | 2021-11-08T13:22:06 | 2021-11-08T13:22:06 | 423,164,472 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 360 | java | package me.synology.wookoo.shuttle_tracker_driver;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
public class GPSTestActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_gpstest);
}
} | [
"nanayagoon@daum.net"
] | nanayagoon@daum.net |
08ac22c368630ba6cd0da5bfd3a1ae302004bc13 | ac20fb8d711da6e4c30accaf72617de6998a309b | /src/Stock/supplierManagement/SupplierContact.java | 2a858b6467dbd284fcc720ece51adab039252db4 | [] | no_license | Nivlipetz1/bgu2 | 1e23379a8b77901d230f44b411e256a4e747a09e | 3d60899a8319e7c011f369d9ae928023b0b49a24 | refs/heads/master | 2021-01-17T13:25:50.405840 | 2016-06-21T10:35:43 | 2016-06-21T10:35:43 | 57,985,708 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 839 | java | package Stock.supplierManagement;
import java.util.LinkedList;
import java.util.List;
public class SupplierContact {
private String name, email;
private List<String> phoneNumbers;
public SupplierContact(String name, String email) {
this.name = name;
this.email = email;
phoneNumbers = new LinkedList<String>();
}
public String getName() {
return name;
}
public String getEmail() {
return email;
}
public void changeEmail(String email) {
this.email = email;
}
public String[] getPhoneNumbers() {
String[] array = new String[phoneNumbers.size()];
return phoneNumbers.toArray(array);
}
public void addPhoneNumber(String number) {
phoneNumbers.add(number);
}
public void removePhoneNumber(String number) {
for (String i : phoneNumbers) {
if (i.equals(number))
phoneNumbers.remove(i);
}
}
}
| [
"Jalon0@gmail.com"
] | Jalon0@gmail.com |
4da61a83dd5dbd50d3e83981941146f25886dc37 | 39c7c26fd4acdbd4abf1f0005ba609c56ac16bd9 | /app/src/main/java/com/example/planyourmurder/ui/model/TokenHandler.java | a5db78d0626a20dd875dea84fabda955f24d9592 | [] | no_license | PYM-Team/AndroidApp | 45e9a79720af1b6b27711e89d1b1662aacc84fd9 | 48e31ce419c22f5fe4a68823fe87dbfcf5a00d6c | refs/heads/master | 2021-04-18T07:31:07.096867 | 2020-05-29T09:13:22 | 2020-05-29T09:13:22 | 249,517,600 | 0 | 1 | null | 2020-04-25T08:54:57 | 2020-03-23T18:53:59 | Java | UTF-8 | Java | false | false | 291 | java | package com.example.planyourmurder.ui.model;
public class TokenHandler {
private static String token;
public static synchronized String getToken(){
return token;
}
public static synchronized void setToken(String token){
TokenHandler.token = token;
}
}
| [
"hug1910@live.fr"
] | hug1910@live.fr |
2891dc5771c43b6e2659a1ea286939346f46bf47 | 0d9c97a1d2bbaa095b7ccc5fc7954c9970cae961 | /src/main/java/com/cg/onlineplantnursery/Entity/Planter.java | 0c84a469c7f1b87cfde465b2468d4ae774c707f4 | [] | no_license | PrashunMahajan/OnlinePlantNursery1 | b5ba8302ce54b297cf5b4f486f1cfee120752b48 | 25667aab6fda2d9bb411ee7a5b020d3a5c1fe7e2 | refs/heads/master | 2023-08-13T16:26:28.077648 | 2021-10-11T16:57:24 | 2021-10-11T16:57:24 | 416,014,436 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,447 | java | package com.cg.onlineplantnursery.Entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
@ToString
@Builder
@JsonIgnoreProperties(ignoreUnknown = true)
@JsonInclude(JsonInclude.Include.NON_DEFAULT)
public class Planter {
@Id
@GeneratedValue(strategy=GenerationType.AUTO)
private Integer planterId;
@Column(name = "height")
private float planterheight;
@Column(name = "capacity")
@Min(value = 1)
private int planterCapacity;
@Column(name = "drinage")
@Min(value = 2)
private int drinageHoles;
@Column(name = "pcolor")
@NotBlank(message = "Planter color must be inserted")
private String planterColor;
@Column(name = "pshape")
@NotBlank(message = "Planter shape must be inserted")
private String planterShape;
@Column(name = "stock")
@Min(value = 50)
private int planterStock;
@Column(name = "cost")
private double planterCost;
}
| [
"prashun.mahajan@capgemini.com"
] | prashun.mahajan@capgemini.com |
7c6537144fe69f13d19d6fdc30f660086cca2703 | 51be682f7a57732aedc3cf3c2f3778c9bf9c6955 | /smt-waiting-test/smt-waiting-aspect-integration/smt-waiting-aspect-test-executions/src/main/java/shiver/me/timbers/waiting/factory/ClearWaitingIncludeClassFactory.java | 1c6bac29b6191e5d22165383705723b87f88d70a | [
"Apache-2.0"
] | permissive | shiver-me-timbers/smt-waiting-parent | 3b9537ef94722e52f711f87d46a003cbeb93aaac | 91bfce941fca6ecbe44fe1da30375a4fc94403cb | refs/heads/main | 2023-08-04T12:47:10.114318 | 2023-07-23T05:33:31 | 2023-07-23T05:33:31 | 40,812,781 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 487 | java | package shiver.me.timbers.waiting.factory;
import shiver.me.timbers.waiting.execution.ClearAndAddIncludeWaitingForClass;
public class ClearWaitingIncludeClassFactory extends ClearWaitingIncludeFactory {
public ClearWaitingIncludeClassFactory() {
this(new ClearAndAddIncludeWaitingForClass());
}
public ClearWaitingIncludeClassFactory(ClearAndAddIncludeWaitingForClass clearAndAddIncludeWaitingForClass) {
super(clearAndAddIncludeWaitingForClass);
}
}
| [
"karl.bennett.smt@gmail.com"
] | karl.bennett.smt@gmail.com |
5f481640dd40b74ddf9031c7e634f69d30129926 | 3a89f4356d924857cc1786a82e4845907b924221 | /Java-Swing-Basics/07-Animation-Basics/src/com/liubin/Circle.java | a67e48c744a21a79a6c00ce09f9da0a5de5d6322 | [] | no_license | 870005335/algorithm_visualization | b00772f9ae99c81ef94270624277b1bd9f494d5a | df7dd74f81e1c2df342e967319f60c79fab084b5 | refs/heads/master | 2022-07-11T00:05:56.963939 | 2020-05-14T10:40:02 | 2020-05-14T10:40:02 | 262,473,161 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 393 | java | package com.liubin;
public class Circle {
public int x, y;
private int r;
public int vx, vy;
public Circle(int x, int y, int r, int vx, int vy) {
this.x = x;
this.y = y;
this.r = r;
this.vx = vx;
this.vy = vy;
}
public int getR() {
return r;
}
public void move() {
x += vx;
y += vy;
}
}
| [
"870005335@qq.com"
] | 870005335@qq.com |
a74a45ae6fba9216200b427949f0e63cbfb21737 | 9df0675b83d569976166a2f07c336b0b5f604e97 | /Set_JeuDeCarte/app/src/androidTest/java/com/example/fanjiang/set_jeudecarte/ExampleInstrumentedTest.java | 790b20313e790ef762359a79c307d1263af17ee6 | [] | no_license | FanJiang718/Set-Card-game-on-Android- | 7222f2c2703508922116f7301e7778049406e434 | 5ad0bbece7259df9ef569fa11c7ed4c4c9f9c806 | refs/heads/master | 2020-12-11T16:15:40.501476 | 2020-01-14T20:57:22 | 2020-01-14T20:57:22 | 233,895,011 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 771 | java | package com.example.fanjiang.set_jeudecarte;
import android.content.Context;
import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() throws Exception {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getTargetContext();
assertEquals("com.example.fanjiang.set_jeudecarte", appContext.getPackageName());
}
}
| [
"jiangfan718@gmail.com"
] | jiangfan718@gmail.com |
26053a7b06e6e6dea1302065c1668200204df673 | 42e8e3b9b0d986c8fd94c6766f2201897bf22359 | /Large Scale Programming/src/org/howard/edu/lsp/assignment2/Combinations.java | 5217b5b0bd208b5073e49208db74a3ed13149b6a | [] | no_license | keerthanap24/lsp-2021 | b9dd63968742855971677bc68c23b811f33479a3 | 71182c6864a3629ee98168a6c24383bebcf5ee68 | refs/heads/main | 2023-04-05T20:05:35.236461 | 2021-04-23T18:28:14 | 2021-04-23T18:28:14 | 348,078,254 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,084 | java | package org.howard.edu.lsp.assignment2;
import java.util.ArrayList;
import java.util.Arrays;
public class Combinations{
/**
*
* @param nums
* @param newNum
* @param sum
*/
public void findCombinationsRecursive(ArrayList<Integer> nums, ArrayList<Integer> newNum, int sum){
int s = 0;
for (int x: newNum){
s += x;
}
if (s == sum){
System.out.println("sum(" + Arrays.toString(newNum.toArray()) + ") = " + sum);
}
if (s >= sum){
return;
}
for(int i = 0; i < nums.size(); i++) {
ArrayList<Integer> remainder = new ArrayList<Integer>();
int n = nums.get(i);
for (int j = i + 1; j < nums.size(); j++){
remainder.add(nums.get(j));
}
ArrayList<Integer> newNum2 = new ArrayList<Integer>(newNum);
newNum2.add(n);
findCombinationsRecursive(remainder, newNum2, sum);
}
}
/**
*
* @param nums
* @param sum
*/
public void findCombinations(ArrayList<Integer> nums, int sum) {
findCombinationsRecursive(nums, new ArrayList<Integer>(), sum);
}
} | [
"kpullela24@gmail.com"
] | kpullela24@gmail.com |
d5bc5cb39d1a8c8c6829651410c49f690bf786f2 | 14a53968fe25279e0a0752093d10158dcdb9f3f5 | /src/main/java/org/fcx/mytool/entity/proxy/clash/ProxyGroup.java | 720a9edbcc2ae26426cd88a41a55a36afb27637e | [] | no_license | HecateFu/mytool | c8b8e53769108c9cb266f89171cbbac5b390972e | a38b9083e32221a4d112f8f4667e6ddf24e8eded | refs/heads/master | 2023-01-10T16:03:43.284732 | 2020-11-08T13:36:22 | 2020-11-08T13:36:22 | 297,011,714 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 584 | java | package org.fcx.mytool.entity.proxy.clash;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.util.List;
@Getter
@Setter
@ToString
@JsonInclude(JsonInclude.Include.NON_NULL)
public class ProxyGroup {
private String name;
private String type;
private List<String> proxies;
private String url;
private Integer interval;
public ProxyGroup(String name,String type,List<String> proxies){
this.name = name;
this.type = type;
this.proxies = proxies;
}
}
| [
"hecatefu@outlook.com"
] | hecatefu@outlook.com |
3a99f0fdf17ab5d8f76dd18f025008c19d644e14 | 2ee773cbdc216c9165029632eb36fedd8de36ca5 | /app/src/main/java/com/qualcomm/hardware/lynx/commands/core/LynxSetDIODirectionCommand.java | b7f345d8644907096bfc5ceaf5028953834f6b03 | [] | no_license | Killian-Townsend/Custom-FTC-Driver-Station-2021 | 6bee582afdb032ad2921b394280a2321f0f815ec | 16e8999d7593ef2c4189902bf2d376db8a3a6b41 | refs/heads/master | 2023-03-28T04:48:30.704409 | 2021-03-19T01:09:18 | 2021-03-19T01:09:18 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,038 | java | package com.qualcomm.hardware.lynx.commands.core;
import com.qualcomm.hardware.lynx.LynxModuleIntf;
import com.qualcomm.hardware.lynx.commands.LynxDatagram;
import com.qualcomm.hardware.lynx.commands.standard.LynxAck;
import com.qualcomm.robotcore.hardware.DigitalChannel;
import com.qualcomm.robotcore.hardware.configuration.LynxConstants;
import java.nio.ByteBuffer;
public class LynxSetDIODirectionCommand extends LynxDekaInterfaceCommand<LynxAck> {
public final int cbPayload = 2;
private int direction;
private int pin;
public LynxSetDIODirectionCommand(LynxModuleIntf paramLynxModuleIntf) {
super(paramLynxModuleIntf);
}
public LynxSetDIODirectionCommand(LynxModuleIntf paramLynxModuleIntf, int paramInt, DigitalChannel.Mode paramMode) {
this(paramLynxModuleIntf);
LynxConstants.validateDigitalIOZ(paramInt);
this.pin = paramInt;
if (paramMode == DigitalChannel.Mode.INPUT) {
paramInt = 0;
} else {
paramInt = 1;
}
this.direction = paramInt;
}
public void fromPayloadByteArray(byte[] paramArrayOfbyte) {
ByteBuffer byteBuffer = ByteBuffer.wrap(paramArrayOfbyte).order(LynxDatagram.LYNX_ENDIAN);
this.pin = byteBuffer.get();
this.direction = byteBuffer.get();
}
public DigitalChannel.Mode getMode() {
return (this.direction == 0) ? DigitalChannel.Mode.INPUT : DigitalChannel.Mode.OUTPUT;
}
public int getPin() {
return this.pin;
}
public boolean isResponseExpected() {
return false;
}
public byte[] toPayloadByteArray() {
ByteBuffer byteBuffer = ByteBuffer.allocate(2).order(LynxDatagram.LYNX_ENDIAN);
byteBuffer.put((byte)this.pin);
byteBuffer.put((byte)this.direction);
return byteBuffer.array();
}
}
/* Location: C:\Users\Student\Desktop\APK Decompiling\com.qualcomm.ftcdriverstation_38_apps.evozi.com\classes-dex2jar.jar!\com\qualcomm\hardware\lynx\commands\core\LynxSetDIODirectionCommand.class
* Java compiler version: 6 (50.0)
* JD-Core Version: 1.1.3
*/ | [
"admin@thatsfuckingstupid.org"
] | admin@thatsfuckingstupid.org |
b7efeaaca20daca51aff8b7c4605888e18207253 | 55f324232d91cf58691d445c076ce2d6d8e39bda | /src/main/java/com/growlerstation/gs1221/config/MvcConfiguration.java | e43b27f4578d2623d7c67fd1e08dbc9a1add0a76 | [] | no_license | vaughnjavier/growlerstation | c6924b415cc8dbbda686d3f5df3aab50b9638c3b | d739c5c9d5e5aa829634fab0fe2adebfbcb18135 | refs/heads/master | 2021-01-19T19:37:44.841776 | 2015-10-06T02:21:05 | 2015-10-06T02:21:05 | 34,579,060 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,625 | java | package com.growlerstation.gs1221.config;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionInterceptor;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
@Configuration
@ComponentScan(basePackages = "com.growlerstation.gs1221")
@EnableWebMvc
public class MvcConfiguration extends WebMvcConfigurerAdapter {
@Bean
public ViewResolver getViewResolver() {
InternalResourceViewResolver resolver = new InternalResourceViewResolver();
resolver.setPrefix("/WEB-INF/views/");
resolver.setSuffix(".jsp");
return resolver;
}
@Bean
public DataSource dataSource() {
DriverManagerDataSource dataSource = new DriverManagerDataSource("jdbc:mysql://localhost:3306/growler_station", "gs1221", "2Bobbiejo@");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
return dataSource;
}
@Bean
public JdbcTemplate jdbcTemplate() throws Exception {
return new JdbcTemplate(dataSource());
}
@Bean
public PlatformTransactionManager transactionManager() throws Exception {
return new DataSourceTransactionManager(dataSource());
}
@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
}
@Bean
public TransactionAttributeSource annotationTransactionAttributeSource() {
return new AnnotationTransactionAttributeSource();
}
@Bean
public TransactionInterceptor transactionInterceptor() throws Exception{
return new TransactionInterceptor(transactionManager(), annotationTransactionAttributeSource());
}
}
| [
"ralvarado@src.systemsmadesimple.com"
] | ralvarado@src.systemsmadesimple.com |
c277fc012a474b1fb950058025252c3bcba3082d | e3695788c0a286ba2f9ace6f9fb3d62c473f5edf | /src/Ex18PrimitivesInMemory.java | e79c52b6038a2231b229430cd8897de5c48f69a9 | [] | no_license | eimearreilly/LearnObjectOrientatedTheHardWay | 47186814a3d1575d9bd389cc118a8e3e8cc183fa | 74403de364ae930f814547ea224d1f4d0b7e6206 | refs/heads/master | 2021-01-18T13:11:14.375130 | 2017-03-06T15:22:52 | 2017-03-06T15:22:52 | 80,731,611 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 543 | java | import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
/**
* Created by eimearreilly on 03/02/2017.
*/
public class Ex18PrimitivesInMemory {
public static void main(String[] args){
int age = 41;
double btc = 0.11307678;
boolean veracity = true;
short month = 11;
byte day =31;
long debt = 12323427532452L;
float mass = 78.971F;
System.out.println(btc);
System.out.println(debt);
System.out.println();
String name = "Gosling";
}
}
| [
"eimear.reilly1@gmail.com"
] | eimear.reilly1@gmail.com |
0ea16b81449327ddc52af47b7f682d85a0cddba9 | 752974a9dec17caa7ff48d16958b1928e396ed19 | /src/com/Pocket_Money/Account.java | 2f8daad4a5bd40862088e381028fb0a2c0870120 | [] | no_license | 2ssue/pocket_money | 727278c71511a5b10cb7446a4dfa61f1806c8cfe | 643b0974aa203389f67e3fb3a80de02be8701131 | refs/heads/master | 2020-05-14T18:59:11.085294 | 2019-05-26T07:47:31 | 2019-05-26T07:47:31 | 181,919,981 | 0 | 0 | null | null | null | null | UHC | Java | false | false | 3,179 | java | package com.Pocket_Money;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Account {
private List<MoneyTransaction> account;
private int nBalance;
private int nLimit;
private String sAccountName;
public Account(String accountName, int balance) {
this.setBalance(balance);
this.sAccountName = accountName;
this.account = new ArrayList<>();
File accountFile = new File(".\\Account\\" + this.sAccountName+".txt");
try {
FileReader fileReader = new FileReader(accountFile);
BufferedReader bufferReader = new BufferedReader(fileReader);
String sLine = "";
try {
bufferReader.readLine();
bufferReader.readLine();
while((sLine = bufferReader.readLine()) != null){
String[] transaction = this.parsingAccountFile(sLine);
int money = Integer.parseInt(transaction[1]);
String category = transaction[2];
boolean fixedCost;
if(transaction.equals("y")) fixedCost = true;
else fixedCost = false;
this.account.add(new MoneyTransaction(money, transaction[0], transaction[3], category, fixedCost));
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
try {
accountFile.createNewFile();
} catch (IOException e1) {
e1.printStackTrace();
System.out.println("계좌를 생성하는 중 오류가 발생했습니다.");
}
}
}
private String[] parsingAccountFile(String s) {
return s.split(" ");
}
public String getAccountName() {
return sAccountName;
}
public void addTransaction(MoneyTransaction transaction) {
this.account.add(transaction);
this.nBalance += transaction.getMoney();
System.out.println(sAccountName +"의 현재 잔액은 " + nBalance + "입니다.");
if(this.nBalance <= this.nLimit) System.out.println("잔액이 부족합니다");
}
public void deleteAllTransaction() {
account.removeAll(account);
}
public Iterator<MoneyTransaction> iteratorTransaction(){
return account.iterator();
}
public int getBalance() {
return nBalance;
}
public void setBalance(int balance) {
this.nBalance = balance;
}
public int getLimit() {
return nLimit;
}
public void setLimit(int limit) {
this.nLimit = limit;
}
public void saveAccount() {
File accountFile = new File(".\\Account\\" + this.sAccountName+".txt");
try {
BufferedWriter bufferWriter = new BufferedWriter(new FileWriter(accountFile));
if(accountFile.isFile() && accountFile.canWrite()) {
Iterator<MoneyTransaction> transaction = this.iteratorTransaction();
bufferWriter.write(Integer.toString(this.nBalance));
bufferWriter.newLine();
bufferWriter.newLine();
while(transaction.hasNext()) {
bufferWriter.write(transaction.next().toString());
bufferWriter.newLine();
}
bufferWriter.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} | [
"42017052+2ssue@users.noreply.github.com"
] | 42017052+2ssue@users.noreply.github.com |
022e8d7f2240a94c1011038b90d81bbec6bace67 | 56bd998eb4bcc151885e40c0917744aaf5273752 | /src/main/java/org/prebid/server/hooks/v1/entrypoint/EntrypointPayload.java | d6dd6e8b61cd8cba0ab1d89e83678776dd52b957 | [
"Apache-2.0"
] | permissive | adpushup/prebid-server-java | b808923864f487f4497b5985aeef15ce8f813465 | f1ef567d30f02078f0b252ae313566520162997b | refs/heads/master | 2022-12-11T06:48:27.454781 | 2022-10-05T10:45:22 | 2022-10-05T10:45:22 | 251,230,769 | 0 | 2 | Apache-2.0 | 2022-10-27T05:11:16 | 2020-03-30T07:20:50 | Java | UTF-8 | Java | false | false | 248 | java | package org.prebid.server.hooks.v1.entrypoint;
import org.prebid.server.model.CaseInsensitiveMultiMap;
public interface EntrypointPayload {
CaseInsensitiveMultiMap queryParams();
CaseInsensitiveMultiMap headers();
String body();
}
| [
"noreply@github.com"
] | noreply@github.com |
4c63ea094a45e791e4b4b6f162c0a4e4e0d2d836 | 9fc81351e3cfa8b67122e917bc9376c707713cc0 | /kanbanboard/src/main/java/ch/fhnw/imvs/kanban/KanbanApplication.java | 4c0750d7c3ca81f9853a83833bd6382194075ba7 | [
"MIT"
] | permissive | the-s-a-m/kanbanboard | 47c0159b15dc17e3d0a56801c0409da90ac2023c | 6f09687d34a5abd290211b15fcab82ec9cae24c4 | refs/heads/master | 2020-04-06T04:04:08.275752 | 2016-06-02T10:03:59 | 2016-06-02T10:03:59 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,673 | java | /*
* MIT License
*
* Copyright (c) 2016 Maurice Gschwind
* Copyright (c) 2016 Samuel Merki
* Copyright (c) 2016 Joel Wasmer
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package ch.fhnw.imvs.kanban;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class KanbanApplication {
private static Logger log = LoggerFactory.getLogger(KanbanApplication.class);
public static void main(String[] args) {
SpringApplication.run(KanbanApplication.class, args);
}
}
| [
"morbrolhc@gmail.com"
] | morbrolhc@gmail.com |
df67b29b4e432cf87e00180e112671ee91bdc11d | 6c75d64557f71f20291e4191d4081c0c3e4795e8 | /Proyectos/richfaces4-panels-demo/src/main/java/org/richfaces/demo/common/UserBean.java | f9b8162afb307b8b71a1f6b801a1b3aae99106ce | [] | no_license | andrepin29/faces | afbbc1780f9d4cbaaf50f736c002ce25af27d5cc | fbba871b35da47d898888ed9d1bc4c21eb796a8c | refs/heads/master | 2020-03-27T18:42:37.404212 | 2017-06-15T17:54:47 | 2017-06-15T17:54:47 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,695 | java | package org.richfaces.demo.common;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotNull;
import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;
@ManagedBean
@RequestScoped
public class UserBean {
@Length(min = 3, max = 15, message="Name should be defined(3 to 15 characters)")
private String name = "";
private String email = "";
private String password = "";
private String address;
@Min(value = 18, message = "You should be over 18 years to place orders")
@NotNull(message="Age should be specified")
private Integer age;
@NotEmpty(message="City should be specified")
private String city=null;
@NotEmpty(message="Country should be specified")
private String country=null;
private String job;
private String recordStatus;
private String zip;
public UserBean() {
super();
}
public void store() {
this.recordStatus = "User " + this.name + " stored succesfully";
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getRecordStatus() {
return recordStatus;
}
public void setRecordStatus(String recordStatus) {
this.recordStatus = recordStatus;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public String nameItJohn() {
setName("John");
return null;
}
public String nameItMark() {
setName("Mark");
return null;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getZip() {
return zip;
}
public void setZip(String zip) {
this.zip = zip;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
}
| [
"jose.diaz@joedayz.pe"
] | jose.diaz@joedayz.pe |
030a98c3577d609753d0c21d3ca7eac76602da9a | 3ccfdda833832a35ac41e2d1d79e85e197546833 | /src/day45_exceptionHandling/BadArray.java | 710a006bda5825b486639042a988f3a82d106e99 | [] | no_license | alperturan/JavaProgramming_EU5 | d917adc5ad4226e4591e19d5db632ff8f0bec82c | f543c2081649ab95ca928f2b08082835de523c3b | refs/heads/main | 2023-06-19T12:38:36.749427 | 2021-07-17T19:49:41 | 2021-07-17T19:49:41 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 266 | java | package day45_exceptionHandling;
public class BadArray {
public static void main(String[] args) {
int[] number = {1,2,3};
for(int i=0;i<=number.length;i++) {
System.out.println(number[i]);
}
System.out.println("Learning exception");
}
}
| [
"Muhtar.Mahmut0519@gmail.com"
] | Muhtar.Mahmut0519@gmail.com |
f37b24984c1ff55c0ac5b56f9d917fd4cb48479c | cb9992fd8a8005056a67c783aa46086c8e55290f | /hudi-flink-datasource/hudi-flink/src/main/java/org/apache/hudi/sink/bulk/AutoRowDataKeyGen.java | bcae6fcd7b6cb56952e8275aaf053b548fa3919a | [
"CC0-1.0",
"MIT",
"JSON",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | apache/hudi | cb3f365f40570357777e9d6e83b93c554f50e707 | 0e50d7586a7719eab870c8d83e3566bb549d64b6 | refs/heads/master | 2023-09-02T14:55:11.040855 | 2023-09-02T11:06:37 | 2023-09-02T11:06:37 | 76,474,200 | 3,615 | 1,833 | Apache-2.0 | 2023-09-14T19:03:11 | 2016-12-14T15:53:41 | Java | UTF-8 | Java | false | false | 2,227 | java | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hudi.sink.bulk;
import org.apache.hudi.common.model.HoodieRecord;
import org.apache.hudi.common.util.Option;
import org.apache.hudi.configuration.FlinkOptions;
import org.apache.flink.configuration.Configuration;
import org.apache.flink.table.data.RowData;
import org.apache.flink.table.types.logical.RowType;
/**
* Key generator for {@link RowData} that use an auto key generator.
*/
public class AutoRowDataKeyGen extends RowDataKeyGen {
private final int taskId;
private final String instantTime;
private int rowId;
public AutoRowDataKeyGen(
int taskId,
String instantTime,
String partitionFields,
RowType rowType,
boolean hiveStylePartitioning,
boolean encodePartitionPath) {
super(Option.empty(), partitionFields, rowType, hiveStylePartitioning, encodePartitionPath, false, Option.empty());
this.taskId = taskId;
this.instantTime = instantTime;
}
public static RowDataKeyGen instance(Configuration conf, RowType rowType, int taskId, String instantTime) {
return new AutoRowDataKeyGen(taskId, instantTime, conf.getString(FlinkOptions.PARTITION_PATH_FIELD),
rowType, conf.getBoolean(FlinkOptions.HIVE_STYLE_PARTITIONING), conf.getBoolean(FlinkOptions.URL_ENCODE_PARTITIONING));
}
@Override
public String getRecordKey(RowData rowData) {
return HoodieRecord.generateSequenceId(instantTime, taskId, rowId++);
}
}
| [
"noreply@github.com"
] | noreply@github.com |
c897d8639d39c7303a3d6a7727854041a3aa5850 | 20e3b9677e325cb7dab5d303dea249ef8ee5fb10 | /fapi/src/main/java/by/training/nc/sd2/fapi/models/AuthInfoModel.java | b4e7151a42db41ddb018ae55f01a3d733e3be61a | [] | no_license | ncdevschool2018-2/SD-3_AndreevIvan | 88b58d3f75d6138a7fdfac502521a37157866982 | 056a072198a70e659340c6c636ea08616e9c5b3d | refs/heads/master | 2020-03-30T20:57:05.287428 | 2018-12-18T21:11:47 | 2018-12-18T21:11:47 | 151,611,323 | 0 | 1 | null | null | null | null | UTF-8 | Java | false | false | 125 | java | package by.training.nc.sd2.fapi.models;
public class AuthInfoModel {
public String login;
public String password;
}
| [
"van079@mail.ru"
] | van079@mail.ru |
027a128b424db35fb041f36eb7d9345b6702ff6c | bd6920bbe8762e1ff8fd53bd1844d95cee1920c7 | /src/br/com/nalthus/efdpc/modelo/RD010.java | 61ff3f6a9ff2660de7b43c3b6b6a4a7541d058c2 | [] | no_license | tbaiocco/sped | 4f08a4427f9e1772ce0ac5fec5050fa702354755 | 19988093ce45ed10d89a718f6e1c457a080e0818 | refs/heads/master | 2021-05-09T14:37:30.978380 | 2018-01-26T15:32:37 | 2018-01-26T15:32:37 | 119,068,923 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 800 | java | package br.com.nalthus.efdpc.modelo;
import java.util.ArrayList;
import java.util.Collection;
public class RD010 {
private String REG = "D010";
private String CNPJ;
private Collection listaRD200 = new ArrayList();
private Collection listaRD500 = new ArrayList();
public String getCNPJ() {
return CNPJ;
}
public void setCNPJ(String cnpj) {
CNPJ = cnpj;
}
public Collection getListaRD200() {
return listaRD200;
}
public void setListaRD200(Collection listaRD200) {
this.listaRD200 = listaRD200;
}
public Collection getListaRD500() {
return listaRD500;
}
public void setListaRD500(Collection listaRD500) {
this.listaRD500 = listaRD500;
}
public String getREG() {
return REG;
}
public void setREG(String reg) {
REG = reg;
}
}
| [
"teo@rsdata.com.br"
] | teo@rsdata.com.br |
d232aef7e1427a122da17ca61a08705029e77822 | 8f87065bc3cb6d96ea2e398a98aacda4fc4bbe43 | /src/Class00000116Better.java | d210080c1c9390ac7f7ce930127c8e10750bdc9f | [] | no_license | fracz/code-quality-benchmark | a243d345441582473532f9b013993f77d59e19ae | c23e76fe315f43bea899beabb856e61348c34e09 | refs/heads/master | 2020-04-08T23:40:36.408828 | 2019-07-31T17:54:53 | 2019-07-31T17:54:53 | 159,835,188 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 269 | java | // original filename: 00001885.txt
// after
public class Class00000116Better {
/**
* {@inheritDoc}
*/
@Override
public boolean isVersionedDirectory(VirtualFile dir) {
return dir.isDirectory() && GitUtil.gitRootOrNull(dir) != null;
}
}
| [
"fraczwojciech@gmail.com"
] | fraczwojciech@gmail.com |
7fb61c7f68d2e5eca9248d2a7d1271919a79ea1e | 04a69418447570c62651cdfec0e440ca58d5730c | /TRAINNING/BigData/Project/StartProject/src/org/SUDriver.java | 167968a829591813b89b24f79a4442e9414fe750 | [] | no_license | jeetsaha5338/College_Study | 4e255d7d946e455522c9b1b4c4017bbc120eabaa | 3b224b2278aff61a281b17de8a73efcb9753235c | refs/heads/master | 2021-05-20T21:50:21.950952 | 2020-04-02T11:36:51 | 2020-04-02T11:36:51 | 252,425,062 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,020 | java | package org;
import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.DoubleWritable;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
public class SUDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
Configuration conf= new Configuration();
Job job=Job.getInstance(conf);
job.setJarByClass(SUDriver.class);
job.setMapperClass(SUMapper.class);
job.setOutputKeyClass(NullWritable.class);
job.setOutputValueClass(Text.class);
job.setNumReduceTasks(1);
FileInputFormat.addInputPath(job,new Path("startup"));
FileOutputFormat.setOutputPath(job,new Path("startup_output"));
job.waitForCompletion(true);
}
}
| [
"jeetsaha093@gmail.com"
] | jeetsaha093@gmail.com |
cf7166b1c1fbd32d33899581c67dfb3710586894 | 83ac3a5651bf967f00e40f3af7c1598549a697f1 | /src/com/javarush/test/level28/lesson06/task01/Solution.java | 923be9af7cb18816219d6076008932148c1c8e85 | [] | no_license | pog-pp/work | f30a0b571ef85deef6a994ee05e0d9eaa4bc2f02 | 75a3133075a5b157539d2caea0fd5fe5f6ac15a7 | refs/heads/master | 2020-12-28T20:54:41.143087 | 2016-03-01T19:48:59 | 2016-03-01T19:48:59 | 48,693,815 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,949 | java | package com.javarush.test.level28.lesson06.task01;
import java.util.List;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ThreadLocalRandom;
/* Magic class
В пакете java.util.concurrent найдите такую реализацию List, у которой
1. итератор не содержит какие-либо данные, вставленные в список после создания итератора
2. внутри данные хранятся в виде массива
3. итератор гарантированно не бросает ConcurrentModificationException
4. допускаются все элементы включая null
5. Исправьте строку List<String> list = null ... в методе main
*/
public class Solution {
public static void main(String[] args) throws InterruptedException {
Solution solution = new Solution();
List<String> list = new CopyOnWriteArrayList<String>();
solution.startUpdatingThread(list);
solution.copyOnWriteSolution(list);
solution.stopUpdatingThread();
/* The output example
size = 0
Element :s781859336
Element :s1453499757
Element :s911312405
Element :s-877520242
Element :s-1636258097
size = 5
Element2 :s781859336
Element2 :s1453499757
Element2 :s911312405
Element2 :s-877520242
Element2 :s-1636258097
Element2 :s-1739827856
Element2 :s-938954654
Element2 :s925086217
size = 8
*/
}
public void copyOnWriteSolution(List<String> list) throws InterruptedException {
System.out.println("size = " + list.size());
System.out.println();
Thread.sleep(20);
for (String element : list) { //создает новую копию на момент создания итератора
System.out.println("Element :" + element);
}
System.out.println("size = " + list.size());
System.out.println();
Thread.sleep(20);
for (String element : list) { //создает новую копию на момент создания итератора
System.out.println("Element2 :" + element);
}
System.out.println("size = " + list.size());
stopUpdatingThread();
}
public void stopUpdatingThread() throws InterruptedException {
t.stop();
t.join();
}
private Thread t;
private void startUpdatingThread(final List<String> list) {
t = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
list.add("s" + ThreadLocalRandom.current().nextInt());
try {
Thread.sleep(5);
} catch (InterruptedException e) {
}
}
}
});
t.start();
}
}
| [
"pog-pp@yandex.ru"
] | pog-pp@yandex.ru |
290d3de454581706e9f50bd6a60eed6a39a47136 | c81518d236a217ee0ef73df5c3a886b41f1ebc07 | /app/build/generated/source/kapt/release/com/rajuyadav/animexmanga/databinding/ItemListBindingImpl.java | 08a88ae85e267024012cf042c81a10d5093068f7 | [] | no_license | raju535482/AnimeXmanga | aa5eb5a83c91953d88d568336048f4a15afa3cc4 | 71178ff1e5fcb77e8d9d389707e189ac559a6b6a | refs/heads/main | 2023-07-30T07:48:03.240597 | 2021-09-14T00:11:11 | 2021-09-14T00:11:11 | 406,159,693 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 6,712 | java | package com.rajuyadav.animexmanga.databinding;
import com.rajuyadav.animexmanga.R;
import com.rajuyadav.animexmanga.BR;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.view.View;
@SuppressWarnings("unchecked")
@javax.annotation.Generated("Android Data Binding")
public class ItemListBindingImpl extends ItemListBinding implements com.rajuyadav.animexmanga.generated.callback.OnClickListener.Listener {
@Nullable
private static final androidx.databinding.ViewDataBinding.IncludedLayouts sIncludes;
@Nullable
private static final android.util.SparseIntArray sViewsWithIds;
static {
sIncludes = null;
sViewsWithIds = new android.util.SparseIntArray();
sViewsWithIds.put(R.id.list_item_imgView_icon, 3);
sViewsWithIds.put(R.id.linearLayout, 4);
sViewsWithIds.put(R.id.list_item_txtView_title, 5);
}
// views
@NonNull
private final androidx.cardview.widget.CardView mboundView0;
@NonNull
private final androidx.constraintlayout.widget.ConstraintLayout mboundView1;
// variables
@Nullable
private final android.view.View.OnClickListener mCallback1;
// values
// listeners
// Inverse Binding Event Handlers
public ItemListBindingImpl(@Nullable androidx.databinding.DataBindingComponent bindingComponent, @NonNull View root) {
this(bindingComponent, root, mapBindings(bindingComponent, root, 6, sIncludes, sViewsWithIds));
}
private ItemListBindingImpl(androidx.databinding.DataBindingComponent bindingComponent, View root, Object[] bindings) {
super(bindingComponent, root, 0
, (android.widget.LinearLayout) bindings[4]
, (android.widget.ImageView) bindings[3]
, (android.widget.TextView) bindings[2]
, (android.widget.TextView) bindings[5]
);
this.listItemTxtViewDescription.setTag(null);
this.mboundView0 = (androidx.cardview.widget.CardView) bindings[0];
this.mboundView0.setTag(null);
this.mboundView1 = (androidx.constraintlayout.widget.ConstraintLayout) bindings[1];
this.mboundView1.setTag(null);
setRootTag(root);
// listeners
mCallback1 = new com.rajuyadav.animexmanga.generated.callback.OnClickListener(this, 1);
invalidateAll();
}
@Override
public void invalidateAll() {
synchronized(this) {
mDirtyFlags = 0x10L;
}
requestRebind();
}
@Override
public boolean hasPendingBindings() {
synchronized(this) {
if (mDirtyFlags != 0) {
return true;
}
}
return false;
}
@Override
public boolean setVariable(int variableId, @Nullable Object variable) {
boolean variableSet = true;
if (BR.mainmodel == variableId) {
setMainmodel((com.rajuyadav.animexmanga.viewmodel.MainViewModel) variable);
}
else if (BR.modelanimeinfo == variableId) {
setModelanimeinfo((com.rajuyadav.animexmanga.modelclass.Animeinfo) variable);
}
else if (BR.intPosition == variableId) {
setIntPosition((java.lang.Integer) variable);
}
else if (BR.imgURL == variableId) {
setImgURL((java.lang.Integer) variable);
}
else {
variableSet = false;
}
return variableSet;
}
public void setMainmodel(@Nullable com.rajuyadav.animexmanga.viewmodel.MainViewModel Mainmodel) {
this.mMainmodel = Mainmodel;
synchronized(this) {
mDirtyFlags |= 0x1L;
}
notifyPropertyChanged(BR.mainmodel);
super.requestRebind();
}
public void setModelanimeinfo(@Nullable com.rajuyadav.animexmanga.modelclass.Animeinfo Modelanimeinfo) {
this.mModelanimeinfo = Modelanimeinfo;
synchronized(this) {
mDirtyFlags |= 0x2L;
}
notifyPropertyChanged(BR.modelanimeinfo);
super.requestRebind();
}
public void setIntPosition(@Nullable java.lang.Integer IntPosition) {
this.mIntPosition = IntPosition;
}
public void setImgURL(@Nullable java.lang.Integer ImgURL) {
this.mImgURL = ImgURL;
}
@Override
protected boolean onFieldChange(int localFieldId, Object object, int fieldId) {
switch (localFieldId) {
}
return false;
}
@Override
protected void executeBindings() {
long dirtyFlags = 0;
synchronized(this) {
dirtyFlags = mDirtyFlags;
mDirtyFlags = 0;
}
com.rajuyadav.animexmanga.viewmodel.MainViewModel mainmodel = mMainmodel;
com.rajuyadav.animexmanga.modelclass.Animeinfo modelanimeinfo = mModelanimeinfo;
java.lang.String stringValueOfModelanimeinfoMangaChap = null;
int modelanimeinfoMangaChap = 0;
if ((dirtyFlags & 0x12L) != 0) {
if (modelanimeinfo != null) {
// read modelanimeinfo.manga_chap
modelanimeinfoMangaChap = modelanimeinfo.getManga_chap();
}
// read String.valueOf(modelanimeinfo.manga_chap)
stringValueOfModelanimeinfoMangaChap = java.lang.String.valueOf(modelanimeinfoMangaChap);
}
// batch finished
if ((dirtyFlags & 0x12L) != 0) {
// api target 1
androidx.databinding.adapters.TextViewBindingAdapter.setText(this.listItemTxtViewDescription, stringValueOfModelanimeinfoMangaChap);
}
if ((dirtyFlags & 0x10L) != 0) {
// api target 1
this.mboundView1.setOnClickListener(mCallback1);
}
}
// Listener Stub Implementations
// callback impls
public final void _internalCallbackOnClick(int sourceId , android.view.View callbackArg_0) {
// localize variables for thread safety
// mainmodel != null
boolean mainmodelJavaLangObjectNull = false;
// mainmodel
com.rajuyadav.animexmanga.viewmodel.MainViewModel mainmodel = mMainmodel;
// modelanimeinfo
com.rajuyadav.animexmanga.modelclass.Animeinfo modelanimeinfo = mModelanimeinfo;
mainmodelJavaLangObjectNull = (mainmodel) != (null);
if (mainmodelJavaLangObjectNull) {
mainmodel.onItemClick(modelanimeinfo);
}
}
// dirty flag
private long mDirtyFlags = 0xffffffffffffffffL;
/* flag mapping
flag 0 (0x1L): mainmodel
flag 1 (0x2L): modelanimeinfo
flag 2 (0x3L): intPosition
flag 3 (0x4L): imgURL
flag 4 (0x5L): null
flag mapping end*/
//end
} | [
"raju535482@gmail.com"
] | raju535482@gmail.com |
e3d1e336ad6eb417796249baabd3baeac279c00b | c7a665116580b21700fc8a74972871e91d655d3f | /ImprovedOOP2_Console/src/Calculator.java | 3486e27392d8683cfdb6dadc6d4928a61b5fc19e | [] | no_license | TsundereKermit/ICS3U-src | 21cd14d3ff0f14081ac8c2fe6014d48c190c549d | 5654135535d989a37c39137e60ae0add5a0864c4 | refs/heads/master | 2020-09-21T17:42:53.740112 | 2019-11-29T14:48:03 | 2019-11-29T14:48:03 | 224,870,222 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 542 | java | public class Calculator
{
// When you are asked to add, you will be given two numbers. Reply (verbally) with their sum. Note that you can only add two numbers � not just one (or none) and not three or more.
public int add(int a, int b)
{
return (a + b);
}
// When you are asked to subtract, you will be given two numbers. Reply (verbally) with their difference. Note that you can only subtract two numbers � not just one (or none) and not three or more.
public int subtract(int a, int b)
{
return (a - b);
}
}
| [
"noreply@github.com"
] | noreply@github.com |
2dbb2b922ff3b78da81f46b82811e22878158560 | 692066e5af0bc60707ed057c86830c6f064931d2 | /app/src/test/java/com/example/haniyeaslani/signupui/ExampleUnitTest.java | 146226680f0128347189f044a1ab32bc4d8c5727 | [] | no_license | hanaaslani/signUp | ccdc4a9946cff106aa5b4dc05222b7e4c283dbfe | 818a2e9bc65855dfd98fec5ce145527ba309bb39 | refs/heads/master | 2020-04-10T10:47:22.013293 | 2018-12-03T22:58:21 | 2018-12-03T22:58:21 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 411 | java | package com.example.haniyeaslani.signupui;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() throws Exception {
assertEquals(4, 2 + 2);
}
} | [
"44503230+hanaaslani@users.noreply.github.com"
] | 44503230+hanaaslani@users.noreply.github.com |
129d17ce65f60e4f656cd5c53a327514eea8c8d0 | 84e4452d49b0ac0f1f2332ddd48c0efe0e9559f2 | /src/by/it/radivonik/jd01_05/Task5.java | 3155e2998808ea0d6a3ccb110cccfae798c0a255 | [] | no_license | loktevalexey/JD2017-02-20 | ea2c25203cefc2c139f1277f17d9999e5c8af522 | f69c964dc9d651c2acef01e6f177aead182f83b6 | refs/heads/master | 2020-04-15T00:13:55.277294 | 2017-06-20T07:53:24 | 2017-06-20T07:53:24 | 86,786,465 | 0 | 1 | null | 2017-03-31T06:37:19 | 2017-03-31T06:37:19 | null | UTF-8 | Java | false | false | 764 | java | package by.it.radivonik.jd01_05;
import static java.lang.Math.*;
/**
* Created by Radivonik on 05.03.2017.
*/
public class Task5 {
public static void calc(double a, double p1, double p2, double dp) {
double y;
double x;
double p = p1;
double pp;
System.out.printf("%10s %10s %10s", "p", "x", "y");
while (p < p2+ dp/2) {
pp = 1.5 * p;
if (pp < 1.5)
x = pow(acos(p),2);
else if (pp >= 1.5 && pp < 3)
x = pow(E,p) + 3.5;
else
x = p + 4.76;
y = a + 1.39 * x;
System.out.printf("\n%10.2f %10.5f %10.5f", p, x, y);
p = p + dp;
}
System.out.println();
}
}
| [
"olsy@tut.by"
] | olsy@tut.by |
7b74935fb030e418cedba54b008a3d1a0b8e4cb0 | 1e96a5420d5b22755a0eec2492f7c4e5a3d190e7 | /wyjatki/exception/exception/stack/Main.java | e3d830a7fc6ad3783d2355860e719870be77d8da | [] | no_license | KamilWieczorek90/MavenExampleKamDawPio | add88d015cab7c50e15129057fa5f8fee048a968 | 275481527f50b839b63426200bac4a8ed7bba0e0 | refs/heads/master | 2020-07-03T16:32:29.706102 | 2019-05-19T18:29:35 | 2019-05-19T18:29:35 | 201,969,697 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 962 | java | package programator02.exception.stack;
public class Main {
public static void main(String[] args) {
Stack stack = new Stack(5);
try {
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.push(5);
stack.push(6);
}
catch (StackOverflowException ex){
//System.out.println("StackOverflowException:" + ex);
System.err.println(ex.getMessage());
// ex.printStackTrace();
}
finally {
System.out.println("Finaly push");
}
try{
for(int i = 0; i < 6; i++){
System.out.println("stack["+ i +"]="+stack.pop());
}
}catch (StackEmptyException ex){
System.out.println("StackEmptyException:" + ex);
ex.printStackTrace();
}finally {
System.out.println("Finaly pop");
}
}
}
| [
"kamilwieczorek90@gmail.com"
] | kamilwieczorek90@gmail.com |
3ef14c668e9ed26370f0063285905e6e19015940 | 192b4e16cce7afa6bfcabb56b78438b41b5cb8e1 | /src/test/java/org/fest/assertions/internal/files/Files_assertHasContent_Test.java | 6ac2e602a25f358db5c126f30362aeba43fa9442 | [
"Apache-2.0"
] | permissive | mostr/fest-assert-2.x | 0e4f38e193c02853dbc9c91fa797e0f10ef41b26 | ef5f13cc723fd2f073e298f21afdf77c2006182d | refs/heads/master | 2020-12-30T19:12:12.724461 | 2012-08-09T19:14:34 | 2012-08-09T19:15:33 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,332 | java | /*
* Created on Jul 21, 2012
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2011 the original author or authors.
*/
package org.fest.assertions.internal.files;
import static junit.framework.Assert.assertSame;
import static junit.framework.Assert.fail;
import static org.fest.assertions.error.ShouldBeFile.shouldBeFile;
import static org.fest.assertions.error.ShouldHaveContent.shouldHaveContent;
import static org.fest.assertions.test.FailureMessages.actualIsNull;
import static org.fest.assertions.test.TestData.someInfo;
import static org.fest.assertions.test.TestFailures.failBecauseExpectedAssertionErrorWasNotThrown;
import static org.fest.util.Collections.list;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
import org.junit.BeforeClass;
import org.junit.Test;
import org.fest.assertions.core.AssertionInfo;
import org.fest.assertions.internal.Files;
import org.fest.assertions.internal.FilesBaseTest;
import org.fest.util.FilesException;
/**
* Tests for <code>{@link Files#assertHasContent(AssertionInfo, File, String, Charset)}</code>.
*
* @author Olivier Michallat
* @author Joel Costigliola
*/
public class Files_assertHasContent_Test extends FilesBaseTest {
private static File actual;
private static String expected;
private static Charset charset;
@BeforeClass
public static void setUpOnce() {
// Does not matter if the values differ, the actual comparison is mocked in this test
actual = new File("src/test/resources/actual_file.txt");
expected = "xyz";
charset = Charset.defaultCharset();
}
@Test
public void should_throw_error_if_expected_is_null() {
thrown.expectNullPointerException("The text to compare to should not be null");
files.assertHasContent(someInfo(), actual, null, charset);
}
@Test
public void should_fail_if_actual_is_null() {
thrown.expectAssertionError(actualIsNull());
files.assertHasContent(someInfo(), null, expected, charset);
}
@Test
public void should_fail_if_actual_is_not_file() {
AssertionInfo info = someInfo();
File notAFile = new File("xyz");
try {
files.assertHasContent(info, notAFile, expected, charset);
} catch (AssertionError e) {
verify(failures).failure(info, shouldBeFile(notAFile));
return;
}
failBecauseExpectedAssertionErrorWasNotThrown();
}
@Test
public void should_pass_if_file_has_text_content() throws IOException {
when(diff.diff(actual, expected, charset)).thenReturn(new ArrayList<String>());
files.assertHasContent(someInfo(), actual, expected, charset);
}
@Test
public void should_throw_error_wrapping_catched_IOException() throws IOException {
IOException cause = new IOException();
when(diff.diff(actual, expected, charset)).thenThrow(cause);
try {
files.assertHasContent(someInfo(), actual, expected, charset);
fail("Expected a FilesException to be thrown");
} catch (FilesException e) {
assertSame(cause, e.getCause());
}
}
@Test
public void should_fail_if_file_does_not_have_expected_text_content() throws IOException {
List<String> diffs = list("line:1, expected:<line1> but was:<EOF>");
when(diff.diff(actual, expected, charset)).thenReturn(diffs);
AssertionInfo info = someInfo();
try {
files.assertHasContent(info, actual, expected, charset);
} catch (AssertionError e) {
verify(failures).failure(info, shouldHaveContent(actual, charset, diffs));
return;
}
failBecauseExpectedAssertionErrorWasNotThrown();
}
}
| [
"joel.costigliola@gmail.com"
] | joel.costigliola@gmail.com |
702c05fc1eb84a97971b083ce84ec22069517a89 | b3633e3ec170e10ffaf07f7125d1bc17ff2b462f | /Benchmarks/ph-commons-ph-commons-parent-pom-9.3.9-patched/ph-commons/src/main/java/com/helger/commons/collection/impl/CommonsHashSet.java | 2567a35902053a31799dcd2056b8c52669874cc8 | [
"Apache-2.0"
] | permissive | dliang2000/hierarchy_analysis | 23c30460050a2451606adf28cc1e09fc101e7457 | 4083b4c9e0daaf519cd1c3f37c4379bf97da9329 | refs/heads/master | 2022-05-31T02:01:24.776781 | 2021-03-30T20:39:58 | 2021-03-30T20:39:58 | 231,459,166 | 1 | 0 | null | 2022-05-20T21:58:23 | 2020-01-02T21:03:00 | Java | UTF-8 | Java | false | false | 3,241 | java | /**
* Copyright (C) 2014-2019 Philip Helger (www.helger.com)
* philip[at]helger[dot]com
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.helger.commons.collection.impl;
import java.util.Collection;
import java.util.HashSet;
import java.util.function.Function;
import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import com.helger.commons.annotation.ReturnsMutableCopy;
import com.helger.commons.collection.ArrayHelper;
import com.helger.commons.collection.CollectionHelper;
/**
* A special {@link HashSet} implementation based on {@link ICommonsSet}.
*
* @author Philip Helger
* @param <ELEMENTTYPE>
* Set element type
*/
public class CommonsHashSet <ELEMENTTYPE> extends HashSet <ELEMENTTYPE> implements ICommonsSet <ELEMENTTYPE>
{
public CommonsHashSet ()
{}
public CommonsHashSet (final int nInitialCapacity)
{
super (nInitialCapacity);
}
public CommonsHashSet (final int nInitialCapacity, @Nonnegative final float fLoadFactor)
{
super (nInitialCapacity, fLoadFactor);
}
public CommonsHashSet (@Nullable final Collection <? extends ELEMENTTYPE> aCont)
{
super (CollectionHelper.getSize (aCont));
if (aCont != null)
addAll (aCont);
}
public CommonsHashSet (@Nullable final Iterable <? extends ELEMENTTYPE> aIterable)
{
addAll (aIterable);
}
public <SRCTYPE> CommonsHashSet (@Nullable final Collection <? extends SRCTYPE> aValues,
@Nonnull final Function <? super SRCTYPE, ? extends ELEMENTTYPE> aMapper)
{
super (CollectionHelper.getSize (aValues));
addAllMapped (aValues, aMapper);
}
public <SRCTYPE> CommonsHashSet (@Nullable final Iterable <? extends SRCTYPE> aValues,
@Nonnull final Function <? super SRCTYPE, ? extends ELEMENTTYPE> aMapper)
{
addAllMapped (aValues, aMapper);
}
public CommonsHashSet (@Nullable final ELEMENTTYPE aValue)
{
super (1);
add (aValue);
}
@SafeVarargs
public CommonsHashSet (@Nullable final ELEMENTTYPE... aValues)
{
super (ArrayHelper.getSize (aValues));
addAll (aValues);
}
public <SRCTYPE> CommonsHashSet (@Nullable final SRCTYPE [] aValues,
@Nonnull final Function <? super SRCTYPE, ? extends ELEMENTTYPE> aMapper)
{
super (ArrayHelper.getSize (aValues));
addAllMapped (aValues, aMapper);
}
@Override
@Nonnull
@ReturnsMutableCopy
public <T> CommonsHashSet <T> createInstance ()
{
return new CommonsHashSet <> ();
}
@Nonnull
@ReturnsMutableCopy
public CommonsHashSet <ELEMENTTYPE> getClone ()
{
return new CommonsHashSet <> (this);
}
}
| [
"q8liang@uwaterloo.ca"
] | q8liang@uwaterloo.ca |
b676ddc51020debb9feda28bd4cf24153a29c0df | c885ef92397be9d54b87741f01557f61d3f794f3 | /tests-without-trycatch/JacksonCore-19/com.fasterxml.jackson.core.json.ReaderBasedJsonParser/BBC-F0-opt-40/3/com/fasterxml/jackson/core/json/ReaderBasedJsonParser_ESTest.java | 6b9e4cdda4bab4dd447bdff2f6af2e45072a9a37 | [
"CC-BY-4.0",
"MIT"
] | permissive | pderakhshanfar/EMSE-BBC-experiment | f60ac5f7664dd9a85f755a00a57ec12c7551e8c6 | fea1a92c2e7ba7080b8529e2052259c9b697bbda | refs/heads/main | 2022-11-25T00:39:58.983828 | 2022-04-12T16:04:26 | 2022-04-12T16:04:26 | 309,335,889 | 0 | 1 | null | 2021-11-05T11:18:43 | 2020-11-02T10:30:38 | null | UTF-8 | Java | false | false | 5,406,168 | java | /*
* This file was automatically generated by EvoSuite
* Thu Oct 14 04:30:44 GMT 2021
*/
package com.fasterxml.jackson.core.json;
import org.junit.Test;
import static org.junit.Assert.*;
import static org.evosuite.shaded.org.mockito.Mockito.*;
import static org.evosuite.runtime.EvoAssertions.*;
import com.fasterxml.jackson.core.Base64Variant;
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.core.SerializableString;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.core.io.IOContext;
import com.fasterxml.jackson.core.io.SerializedString;
import com.fasterxml.jackson.core.json.ReaderBasedJsonParser;
import com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.core.util.BufferRecycler;
import com.fasterxml.jackson.core.util.ByteArrayBuilder;
import com.fasterxml.jackson.core.util.TextBuffer;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import org.evosuite.runtime.EvoRunner;
import org.evosuite.runtime.EvoRunnerParameters;
import org.evosuite.runtime.System;
import org.evosuite.runtime.ViolatedAssumptionAnswer;
import org.evosuite.runtime.mock.java.io.MockFileOutputStream;
import org.evosuite.runtime.testdata.EvoSuiteFile;
import org.evosuite.runtime.testdata.FileSystemHandling;
import org.junit.runner.RunWith;
@RunWith(EvoRunner.class) @EvoRunnerParameters(mockJVMNonDeterminism = true, useVFS = true, useVNET = true, resetStaticState = true, separateClassLoader = true)
public class ReaderBasedJsonParser_ESTest extends ReaderBasedJsonParser_ESTest_scaffolding {
@Test(timeout = 4000)
public void test000() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("07nrs<&t#UWk<{");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)47;
byteArray0[1] = (byte)93;
byteArray0[2] = (byte)19;
byteArray0[3] = (byte)5;
byteArray0[4] = (byte)117;
byteArray0[5] = (byte)9;
byteArray0[6] = (byte) (-28);
byteArray0[7] = (byte)10;
byteArray0[8] = (byte) (-95);
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte)47, (byte)93, (byte)19, (byte)5, (byte)117, (byte)9, (byte) (-28), (byte)10, (byte) (-95)}, byteArray0);
assertEquals(9, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-1832), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals((-1832), readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
// try {
readerBasedJsonParser1._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('n' (code 110)): Expected space separating root-level values
// // at [Source: UNKNOWN; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test001() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = 'g';
charArray0[1] = 'e';
charArray0[3] = '}';
charArray0[4] = 'c';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 102, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 56319, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'g', 'e', '\u0000', '}', 'c'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber(40);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)) in numeric value: Exponent indicator not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000010; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test002() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, jsonEncoding0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
}
@Test(timeout = 4000)
public void test003() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader(">f5mpqz`5_!cND!");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
stringReader1.mark(597);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
IOContext iOContext0 = new IOContext(bufferRecycler0, ">f5mpqz`5_!cND!", true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 734, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(734, readerBasedJsonParser0.getFeatureMask());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(734, readerBasedJsonParser0.getFeatureMask());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(stringReader0, stringReader1);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, int0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(734, readerBasedJsonParser0.getFeatureMask());
assertNotSame(stringReader0, stringReader1);
}
@Test(timeout = 4000)
public void test004() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'f3?pavy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[6];
charArray0[0] = '\u0012';
charArray0[1] = '\u0012';
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertNotNull(byteArrayOutputStream0);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 76, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 731, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(76, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\u0012', '\u0012', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(6, charArray0.length);
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)105;
byteArray0[1] = (byte) (-1);
byteArray0[2] = (byte) (-118);
byteArray0[3] = (byte) (-46);
byteArray0[4] = (byte)80;
byteArray0[5] = (byte)94;
byteArray0[6] = (byte) (-51);
byteArray0[7] = (byte)52;
byteArray0[8] = (byte)28;
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, byteArray0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test005() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals((-1), int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = 'O';
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
charArray0[1] = 'U';
charArray0[0] = 'P';
charArray0[3] = '%';
charArray0[4] = '%';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 64, 11, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertArrayEquals(new char[] {'P', 'U', '\u0000', '%', '%'}, charArray0);
assertEquals(5, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextIntValue(2);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test006() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
StringReader stringReader0 = new StringReader("PIVW(\rL{^F$L?");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
stringReader0.close();
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0.getTextLength();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test007() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(string0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
String string1 = readerBasedJsonParser0.getValueAsString();
assertEquals("0", string1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(string1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
}
@Test(timeout = 4000)
public void test008() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("!4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
Integer integer0 = new Integer(0);
assertEquals(0, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, "!4)O24;p]f4ocT<<", false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[7];
charArray0[0] = 'd';
charArray0[1] = 'U';
charArray0[2] = 'E';
charArray0[3] = 'f';
charArray0[4] = '{';
charArray0[5] = 'O';
charArray0[6] = '+';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2, 3, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'d', 'U', 'E', 'f', '{', 'O', '+'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000011; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test009() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = '4';
charArray0[2] = 'e';
charArray0[3] = 'V';
charArray0[4] = '|';
charArray0[5] = 'l';
charArray0[6] = 'l';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 159, (-2619), false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', '4', 'e', 'V', '|', 'l', 'l'}, charArray0);
assertEquals(7, charArray0.length);
Object object0 = readerBasedJsonParser0.getObjectId();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', '4', 'e', 'V', '|', 'l', 'l'}, charArray0);
assertEquals(7, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
StringReader stringReader1 = new StringReader("twz;Z7vEo");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
// try {
readerBasedJsonParser1.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'twz': was expecting 'null', 'true', 'false' or NaN
// // at [Source: UNKNOWN; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test010() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("=ivCWZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
char[] charArray0 = bufferRecycler0.allocCharBuffer(1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(charArray0);
assertEquals(4000, charArray0.length);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 3183, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(4000, charArray0.length);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000012; line: 1, column: 3196]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test011() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
String string0 = ": was expecting closing quote for a string value";
StringReader stringReader0 = new StringReader(": was expecting closing quote for a string value");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
TextBuffer textBuffer0 = iOContext0.constructTextBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(textBuffer0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 603, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(603, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(603, "");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'was': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000013; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test012() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, integer0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("6.");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 6, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('.' (code 46)) in numeric value: Decimal point not followed by a digit
// // at [Source: java.lang.Integer@0000000014; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test013() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'm';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 35, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 4028, 1, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'m'}, charArray0);
assertEquals(1, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(35, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isNumeric());
assertArrayEquals(new char[] {'8'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000015; line: 1, column: 27]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test014() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertNotSame(iOContext1, iOContext0);
JsonToken jsonToken1 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_TRUE, jsonToken1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(jsonToken1.equals((Object)jsonToken0));
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(57L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(58, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals("true", jsonToken1.asString());
assertFalse(jsonToken1.isNumeric());
assertEquals(9, jsonToken1.id());
assertFalse(jsonToken1.isStructEnd());
assertFalse(jsonToken1.isStructStart());
assertTrue(jsonToken1.isBoolean());
assertTrue(jsonToken1.isScalarValue());
assertNotSame(iOContext1, iOContext0);
assertNotSame(jsonToken1, jsonToken0);
}
@Test(timeout = 4000)
public void test015() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("S5YL|UV1m1HE");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-57L));
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
int int0 = stringReader0.read();
assertEquals(83, int0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 12, 196, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1._isNextTokenNameMaybe(34, "");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 12
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test016() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("0Unr@<ht#UWk<\"");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, (-5812), false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {'\u0000'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test017() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(1);
assertEquals(1L, long0);
int int0 = stringReader0.read();
assertEquals(46, int0);
StringReader stringReader1 = new StringReader("2.2250738585072012e-308");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 19, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(19, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(19, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(stringReader1, stringReader0);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(19, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000016; line: 2, column: 70]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test018() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(1);
assertEquals(1L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = stringReader0.read();
assertEquals(46, int0);
StringReader stringReader1 = new StringReader("2.2250738585072012e-308");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = '@';
charArray0[1] = 'm';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 9, 2, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'@', 'm'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertArrayEquals(new char[] {'8', '0'}, charArray0);
assertEquals(2, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test019() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-168), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-168), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertTrue(boolean0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-168), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
readerBasedJsonParser0._releaseBuffers();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-168), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
}
@Test(timeout = 4000)
public void test020() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("+");
assertNotNull(stringReader0);
stringReader0.close();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0._reportInvalidToken("", "+");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test021() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("MZAN>!y}9=");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-550), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-550), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
StringReader stringReader1 = new StringReader("WI8ZJWQJc,`||:apsl");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader1, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
StringReader stringReader2 = new StringReader("MZAN>!y}9=");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
StringReader stringReader3 = new StringReader("string value");
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertNotNull(stringReader3);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-1548), stringReader3, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals((-1548), readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
char[] charArray0 = new char[2];
charArray0[0] = 'M';
charArray0[1] = ' ';
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, (-1646), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-550), (-1071), true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertNotNull(readerBasedJsonParser2);
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals((-1646), readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertArrayEquals(new char[] {'M', ' '}, charArray0);
assertEquals(2, charArray0.length);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(256, "FU");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('>' (code 62)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000017; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test022() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
Object object0 = new Object();
assertNotNull(object0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("faZWlse");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'faZWlse': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000018; line: 1, column: 15]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test023() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[9];
charArray0[0] = '\t';
charArray0[1] = '\t';
charArray0[2] = '\t';
charArray0[3] = '\t';
charArray0[4] = '\t';
charArray0[5] = '\t';
charArray0[6] = '\t';
charArray0[8] = '\t';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 256, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, '\t', true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(256, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\t', '\t', '\t', '\t', '\t', '\t', '\t', '\u0000', '\t'}, charArray0);
assertEquals(9, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(256, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\t', '\t', '\t', '\t', '\t', '\t', '\t', '\u0000', '\t'}, charArray0);
assertEquals(9, charArray0.length);
// try {
readerBasedJsonParser0.nextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: UNKNOWN; line: 2, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test024() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(137);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
readerBasedJsonParser0._tokenIncomplete = true;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
SerializedString serializedString0 = new SerializedString("");
assertNotNull(serializedString0);
assertEquals("", serializedString0.toString());
assertEquals(0, serializedString0.charLength());
assertEquals("", serializedString0.getValue());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000019; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test025() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("\"St ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(stringReader0, stringReader1);
// try {
readerBasedJsonParser0.getText();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000020; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test026() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(byteArrayBuilder0);
assertNotNull(objectOutputStream0);
assertEquals(4, byteArrayBuilder0.getCurrentSegmentLength());
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertNotNull(byteArrayOutputStream0);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
StringReader stringReader0 = new StringReader("Infinity");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
assertFalse(boolean0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = 'I';
charArray0[1] = '6';
charArray0[2] = 'r';
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 826, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 123, 775, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(826, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'I', '6', 'r'}, charArray0);
assertEquals(3, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, objectOutputStream0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 123
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test027() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("\" can not be represented as BigDecimal");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("\" can not be represented as BigDecimal");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertEquals(6, jsonToken0.id());
assertNull(jsonToken0.asString());
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0.getTextOffset();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000021; line: 1, column: 77]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test028() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("!4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-465), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-465), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test029() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-788));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000022; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test030() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 56, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(56, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
Base64Variant base64Variant0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000023; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test031() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("2EhC`ps[;`&&Wnso");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 117, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(117, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('h' (code 104)) in numeric value: Exponent indicator not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000024; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test032() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
StringReader stringReader0 = new StringReader("98");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 9, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(9, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
int int0 = readerBasedJsonParser0.nextIntValue(35);
assertEquals(98, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(9, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test033() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = '9';
charArray0[1] = 'h';
charArray0[2] = 'L';
charArray0[3] = '@';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 101, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2399, 7, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(101, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'9', 'h', 'L', '@'}, charArray0);
assertEquals(4, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(jsonLocation0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(101, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2400, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals(2399L, jsonLocation0.getCharOffset());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertArrayEquals(new char[] {'9', 'h', 'L', '@'}, charArray0);
assertEquals(4, charArray0.length);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(charArray1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(101, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'9', 'h', 'L', '@'}, charArray0);
assertEquals(4, charArray0.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
stringReader0.close();
boolean boolean1 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
boolean boolean2 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "x)u]v:Kt /");
assertFalse(boolean2);
assertTrue(boolean2 == boolean1);
assertFalse(boolean2 == boolean0);
// try {
readerBasedJsonParser0._reportInvalidToken("");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test034() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("=NoSx|T(DAp5|Q");
assertNotNull(stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, "=NoSx|T(DAp5|Q", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 4128, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(4128, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
byte[] byteArray0 = new byte[9];
byteArray0[0] = (byte)6;
byteArray0[1] = (byte)105;
byteArray0[2] = (byte)40;
byteArray0[3] = (byte)56;
byteArray0[4] = (byte)92;
byteArray0[5] = (byte)13;
byteArray0[6] = (byte)51;
byteArray0[7] = (byte) (-37);
byteArray0[8] = (byte)27;
boolean boolean1 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
assertArrayEquals(new byte[] {(byte)6, (byte)105, (byte)40, (byte)56, (byte)92, (byte)13, (byte)51, (byte) (-37), (byte)27}, byteArray0);
assertEquals(9, byteArray0.length);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(byteArrayBuilder0);
assertNotNull(objectOutputStream0);
assertEquals(4, byteArrayBuilder0.getCurrentSegmentLength());
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertNotNull(byteArrayOutputStream0);
assertEquals("", byteArrayOutputStream0.toString());
assertEquals(0, byteArrayOutputStream0.size());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 110, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 13, 2, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(110, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser1._readBinary((Base64Variant) null, byteArrayOutputStream0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 2
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test035() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("L#aV|xlTY^aV");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[7];
charArray0[0] = '(';
charArray0[1] = '9';
charArray0[2] = '*';
charArray0[3] = '8';
charArray0[4] = '&';
charArray0[5] = '.';
charArray0[6] = '2';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 2, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'(', '9', '*', '8', '&', '.', '2'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber(1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('(' (code 40)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000025; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test036() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("0Unr@<ht#UWk<\"");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000026; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test037() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader0 = new StringReader("0Unr@<ht#UWk<g");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-673), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-673), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
byte[] byteArray0 = iOContext0.allocReadIOBuffer((-3331));
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-673), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000027; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test038() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, false, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
StringReader stringReader0 = new StringReader("btedQ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(91);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\b', char0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("No Base64Variant with name ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(jsonLocation0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals(1L, jsonLocation0.getCharOffset());
assertEquals(2, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
stringReader1.close();
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
boolean boolean1 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe((-945), "{VI&G");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000028; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test039() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("98");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 98, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
boolean boolean1 = readerBasedJsonParser0.nextFieldName((SerializableString) null);
assertFalse(boolean1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(boolean1 == boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(200, charArray0.length);
boolean boolean2 = readerBasedJsonParser0.loadMore();
assertFalse(boolean2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
}
@Test(timeout = 4000)
public void test040() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader1 = new StringReader(" ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 413, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(413, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
long long0 = readerBasedJsonParser0.nextLongValue(2);
assertEquals(2L, long0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(413, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
// Undeclared exception!
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(53, "");
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// }
}
@Test(timeout = 4000)
public void test041() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("=NoSx|T(DAp5|Q");
assertNotNull(stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[7];
charArray0[0] = '.';
charArray0[1] = '.';
charArray0[2] = '.';
charArray0[3] = '.';
charArray0[4] = '.';
charArray0[5] = '.';
charArray0[6] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, 3, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'.', '.', '.', '.', '.', '.', '.'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber((-756));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('.' (code 46)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000029; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test042() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
char[] charArray0 = new char[6];
charArray0[0] = ';';
charArray0[1] = '6';
charArray0[2] = 'S';
charArray0[3] = 'd';
charArray0[4] = '|';
charArray0[5] = '<';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, (-556), true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {';', '6', 'S', 'd', '|', '<'}, charArray0);
assertEquals(6, charArray0.length);
readerBasedJsonParser1._skipCR();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'2', '.', '2', '2', '5', '0'}, charArray0);
assertEquals(6, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isNumeric());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test043() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'f3?pavy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("NaN");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2211), stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-2211), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-2211), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertEquals(8, jsonToken0.id());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._reportInvalidToken("NaN");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'NaN': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000030; line: 1, column: 10]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test044() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("NaN");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2210), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-2210), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
char[] charArray0 = new char[2];
charArray0[0] = '6';
charArray0[1] = '!';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1275), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals((-1275), readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertArrayEquals(new char[] {'6', '!'}, charArray0);
assertEquals(2, charArray0.length);
String string0 = readerBasedJsonParser1.nextTextValue();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(8, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals((-1275), readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'N', 'a'}, charArray0);
assertEquals(2, charArray0.length);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test045() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("{.dq?9HK");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) null);
assertFalse(boolean0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[8];
charArray0[0] = 'f';
charArray0[1] = 'O';
charArray0[2] = '+';
charArray0[3] = '!';
charArray0[4] = 'v';
SerializedString serializedString0 = new SerializedString("{.dq?9HK");
assertNotNull(serializedString0);
assertEquals("{.dq?9HK", serializedString0.toString());
assertEquals(8, serializedString0.charLength());
assertEquals("{.dq?9HK", serializedString0.getValue());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('.' (code 46)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000031; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test046() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("{.d^Bq?9HK");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
SerializedString serializedString0 = new SerializedString("{.d^Bq?9HK");
assertNotNull(serializedString0);
assertEquals(10, serializedString0.charLength());
assertEquals("{.d^Bq?9HK", serializedString0.toString());
assertEquals("{.d^Bq?9HK", serializedString0.getValue());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(10, serializedString0.charLength());
assertEquals("{.d^Bq?9HK", serializedString0.toString());
assertEquals("{.d^Bq?9HK", serializedString0.getValue());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test047() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("\"St ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("\"St ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader2 = new StringReader("D;xh Zg");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
int int0 = readerBasedJsonParser0.nextIntValue(2);
assertEquals(2, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.getValueAsString("\"St ");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000032; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test048() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "*0}Vox|1]";
StringReader stringReader0 = new StringReader("*0}Voxu|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
stringReader0.reset();
StringReader stringReader1 = new StringReader("\"m");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
int int0 = readerBasedJsonParser0.nextIntValue(0);
assertEquals(0, int0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(127, "*0}Vox|1]");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in FIELD_NAME
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000033; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test049() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
char[] charArray0 = new char[5];
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(8000, byteArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
StringReader stringReader1 = new StringReader("Leading zeroes not allowed");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext2 = new IOContext(bufferRecycler0, jsonEncoding0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
JsonEncoding jsonEncoding3 = JsonEncoding.UTF32_BE;
IOContext iOContext4 = iOContext3.withEncoding(jsonEncoding3);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(jsonEncoding3.equals((Object)jsonEncoding1));
assertFalse(iOContext4.equals((Object)iOContext0));
assertFalse(iOContext4.equals((Object)iOContext1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext4);
assertEquals(JsonEncoding.UTF32_BE, iOContext4.getEncoding());
assertTrue(iOContext4.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertNotSame(jsonEncoding3, jsonEncoding1);
assertSame(jsonEncoding3, jsonEncoding2);
assertSame(jsonEncoding3, jsonEncoding0);
assertNotSame(iOContext4, iOContext0);
assertNotSame(iOContext4, iOContext1);
assertSame(iOContext4, iOContext2);
assertSame(iOContext4, iOContext3);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(jsonEncoding0, jsonEncoding3);
assertSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertNotSame(iOContext2, iOContext0);
assertSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(jsonEncoding2, jsonEncoding3);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext4);
assertNotSame(iOContext3, iOContext0);
StringReader stringReader2 = new StringReader("string value");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-1652), stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-1652), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext3, 46, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1071), (-1652), true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser2);
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(46, readerBasedJsonParser2.getFeatureMask());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
char char0 = readerBasedJsonParser2.getNextChar("Fa*hCcPkkUZoI:\"f");
assertEquals('s', char0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(46, readerBasedJsonParser2.getFeatureMask());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertArrayEquals(new char[] {'s', 't', 'r', 'i', 'n'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(stringReader2, stringReader1);
assertNotSame(stringReader2, stringReader0);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(jsonEncoding0, jsonEncoding3);
assertSame(jsonEncoding0, jsonEncoding2);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext4);
assertNotSame(iOContext2, iOContext0);
assertSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(jsonEncoding2, jsonEncoding3);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext4);
assertNotSame(iOContext3, iOContext0);
// try {
readerBasedJsonParser2._isNextTokenNameMaybe(116, "");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('v' (code 118)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.JsonEncoding@0000000034; line: 1, column: -1643]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test050() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("[C");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader1 = new StringReader("[C");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(4000, charArray0.length);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(boolean0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(4000, charArray0.length);
assertNotSame(stringReader0, stringReader1);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(1, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(4000, charArray0.length);
assertNotSame(stringReader0, stringReader1);
}
@Test(timeout = 4000)
public void test051() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-255L));
assertEquals(0L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = stringReader0.read();
assertEquals(39, int0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4941), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-4941), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-4941), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-4941), readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = null;
// try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 55, stringReader0, objectCodec1, charsToNameCanonicalizer2);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test052() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-255L));
assertEquals(0L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
int int0 = stringReader0.read();
assertEquals(39, int0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(byteArrayBuilder0);
assertNotNull(objectOutputStream0);
assertEquals(4, byteArrayBuilder0.getCurrentSegmentLength());
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream();
assertNotNull(byteArrayOutputStream0);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'A';
charArray0[1] = 't';
charArray0[2] = 'm';
charArray0[3] = '`';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 617, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 724, (-6186), true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(617, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertArrayEquals(new char[] {'A', 't', 'm', '`'}, charArray0);
assertEquals(4, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test053() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("0ec`^Sa^f5a)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = 'K';
charArray0[1] = 'K';
charArray0[2] = 'S';
charArray0[3] = '>';
charArray0[4] = 'N';
charArray0[5] = 'k';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 123, (-1137), true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertArrayEquals(new char[] {'K', 'K', 'S', '>', 'N', 'k'}, charArray0);
assertEquals(6, charArray0.length);
boolean boolean0 = readerBasedJsonParser1.loadMore();
assertTrue(boolean0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertArrayEquals(new char[] {'0', 'e', 'c', '`', '^', 'S'}, charArray0);
assertEquals(6, charArray0.length);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// try {
readerBasedJsonParser1.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('c' (code 99)) in numeric value: Exponent indicator not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000035; line: 1, column: -1133]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test054() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("]$^[W/jZ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'L';
charArray0[1] = 'k';
charArray0[2] = '_';
charArray0[3] = ' ';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 8, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'L', 'k', '_', ' '}, charArray0);
assertEquals(4, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._parsePosNumber(9);
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isNumeric());
assertArrayEquals(new char[] {'L', 'k', '_', ' '}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test055() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("}Fb_lH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[7];
charArray0[0] = '&';
charArray0[1] = '^';
charArray0[2] = 'j';
charArray0[3] = 'l';
charArray0[4] = 'W';
charArray0[5] = 'P';
charArray0[6] = '8';
int int0 = stringReader1.read(charArray0);
assertEquals((-1), int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertArrayEquals(new char[] {'&', '^', 'j', 'l', 'W', 'P', '8'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer3, charArray0, 255, 55, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'&', '^', 'j', 'l', 'W', 'P', '8'}, charArray0);
assertEquals(7, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextBooleanValue();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test056() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2000, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer1.makeChild(34);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
StringReader stringReader0 = new StringReader("'r.ezc");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
String string1 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("{", string1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(string1.equals((Object)string0));
assertNotNull(string1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\r', char0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
}
@Test(timeout = 4000)
public void test057() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("com.fahterxml.jackson.coe.Jsonocation");
assertNotNull(stringReader0);
char[] charArray0 = new char[9];
charArray0[0] = 'R';
charArray0[1] = 'L';
charArray0[2] = '^';
charArray0[3] = '`';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charArray0[4] = '_';
charArray0[5] = '2';
charArray0[6] = 'a';
charArray0[7] = 'e';
charArray0[8] = 'D';
int int0 = stringReader0.read(charArray0);
assertEquals(9, int0);
assertArrayEquals(new char[] {'c', 'o', 'm', '.', 'f', 'a', 'h', 't', 'e'}, charArray0);
assertEquals(9, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\r', char0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
int int1 = readerBasedJsonParser0.getTextLength();
assertEquals(0, int1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(int1 == int0);
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test058() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[0] = '\"';
charArray0[2] = '\"';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocTokenBuffer();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1505, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\"', '\u0000', '\"', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertNull(boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\"', '\u0000', '\"', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(charArray0, charArray1);
// try {
readerBasedJsonParser0.getTextLength();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000036; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test059() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn("'f3?palvy").when(objectCodec0).toString();
char[] charArray0 = new char[6];
charArray0[0] = '\t';
charArray0[1] = '\t';
charArray0[3] = '\t';
charArray0[1] = '#';
charArray0[5] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 46, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(objectCodec1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
assertSame(objectCodec1, objectCodec0);
JsonToken jsonToken0 = readerBasedJsonParser0._parsePosNumber(229);
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
}
@Test(timeout = 4000)
public void test060() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[3];
charArray0[0] = '#';
charArray0[1] = 'q';
charArray0[2] = 'H';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {' ', ' ', 'H'}, charArray0);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2823, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 54, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2823, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {' ', ' ', 'H'}, charArray0);
assertEquals(3, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._parsePosNumber(54);
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2823, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertArrayEquals(new char[] {' ', ' ', 'H'}, charArray0);
assertEquals(3, charArray0.length);
}
@Test(timeout = 4000)
public void test061() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
ObjectCodec objectCodec1 = null;
char[] charArray0 = new char[4];
charArray0[0] = '+';
charArray0[1] = 'Q';
charArray0[2] = 'M';
charArray0[3] = '#';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 114, 0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(123, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertArrayEquals(new char[] {'+', 'Q', 'M', '#'}, charArray0);
assertEquals(4, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextLongValue((-786L));
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test062() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
int int0 = stringReader0.read();
assertEquals(45, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-570), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isNumeric());
int int1 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, int1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(int1 == int0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals("Infinity", string0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
}
@Test(timeout = 4000)
public void test063() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("\" can not be represented as BigDecimal");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
Integer integer0 = new Integer((-141));
assertEquals((-141), (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1922), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1922), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1922), readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertNotSame(stringReader0, stringReader1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
// try {
readerBasedJsonParser0.getTextOffset();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.Integer@0000000037; line: 1, column: 77]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test064() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 8, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
char[] charArray0 = new char[3];
charArray0[0] = '=';
charArray0[1] = 'f';
charArray0[2] = '=';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3472, 931, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertArrayEquals(new char[] {'=', 'f', '='}, charArray0);
assertEquals(3, charArray0.length);
readerBasedJsonParser1._skipCR();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertArrayEquals(new char[] {'=', 'f', '='}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test065() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[4];
charArray0[0] = 'l';
charArray0[1] = '&';
charArray0[2] = '}';
charArray0[3] = 'W';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2964), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals((-2964), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'l', '&', '}', 'W'}, charArray0);
assertEquals(4, charArray0.length);
Object object0 = readerBasedJsonParser0.getEmbeddedObject();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals((-2964), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'l', '&', '}', 'W'}, charArray0);
assertEquals(4, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2361, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(2361, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
JsonToken jsonToken0 = readerBasedJsonParser1.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(8, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(2361, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec2, charsToNameCanonicalizer1, charArray0, 1, 110, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser2.getFeatureMask());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertArrayEquals(new char[] {'l', '&', '}', 'W'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser2._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('&' (code 38)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000038; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test066() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "3q g]SJW1", true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1518, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1518, readerBasedJsonParser0.getFeatureMask());
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1518, readerBasedJsonParser0.getFeatureMask());
char[] charArray0 = new char[6];
charArray0[0] = '#';
charArray0[1] = 'B';
charArray0[2] = 'z';
charArray0[3] = 'p';
charArray0[4] = '4';
charArray0[5] = 'p';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 696, 33, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'#', 'B', 'z', 'p', '4', 'p'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser1._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test067() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("93");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
readerBasedJsonParser0.nextToken();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
}
@Test(timeout = 4000)
public void test068() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("98");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 98, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = readerBasedJsonParser0.nextIntValue(56319);
assertEquals(56319, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(98, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(33, "");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('!' (code 33)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000039; line: 2, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test069() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
Object object0 = new Object();
assertNotNull(object0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("DOUBLE");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 224, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(4000, charArray0.length);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000040; line: 1, column: 237]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test070() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("sI},`|t0JM-");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = iOContext1.allocConcatBuffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1773, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1773, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('s', char0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1773, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader1 = new StringReader("sI},`|t0JM-");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('}' (code 125)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000041; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test071() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
int int0 = stringReader0.read();
assertEquals(45, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-570), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(jsonToken0.isStructEnd());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
}
@Test(timeout = 4000)
public void test072() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("Infinity");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-210), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-210), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-210), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
// try {
readerBasedJsonParser0._parsePosNumber(114);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('y' (code 121)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000042; line: 1, column: 17]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test073() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '\"';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocTokenBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', '\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertNull(boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', '\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(charArray0, charArray1);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(4, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertEquals(6, jsonToken0.id());
assertArrayEquals(new char[] {'\"', '\"', '\"', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(charArray0, charArray1);
// try {
readerBasedJsonParser0.getTextCharacters();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000043; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test074() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("p|s3[b");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-823), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals((-823), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals((-823), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
StringReader stringReader1 = new StringReader("p|s3[b");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('[' (code 91)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000044; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test075() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
char[] charArray0 = new char[1];
charArray0[0] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 484, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 1, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(484, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'#'}, charArray0);
assertEquals(1, charArray0.length);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(objectCodec1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(484, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'#'}, charArray0);
assertEquals(1, charArray0.length);
assertSame(objectCodec1, objectCodec0);
long long0 = readerBasedJsonParser0.nextLongValue((-2147483648L));
assertEquals((-2147483648L), long0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(484, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {' '}, charArray0);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test076() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("!4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-465), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-465), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-465), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = '#';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, 4, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertArrayEquals(new char[] {'#'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000045; line: 2, column: 35]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test077() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "/Qh=69GKH|m#");
assertFalse(boolean0);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("/Qh=69GKH|m#");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 91, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('/', char0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader1 = new StringReader("/Qh=69GKH|m#");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1L, jsonLocation0.getCharOffset());
assertEquals(2, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader0, stringReader1);
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader0, stringReader1);
boolean boolean1 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, " ^^(K[");
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(526, " ^^(K[");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('=' (code 61)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000046; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test078() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
StringReader stringReader1 = new StringReader("'f3?palvy");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 2323, 33, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
assertEquals(2, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
readerBasedJsonParser0._objectCodec = objectCodec1;
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\'', 'f'}, charArray0);
assertEquals(2, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\f', char0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\'', 'f'}, charArray0);
assertEquals(2, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test079() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
char[] charArray0 = new char[6];
charArray0[0] = '\t';
charArray0[1] = '\t';
charArray0[3] = '\t';
charArray0[1] = '#';
charArray0[5] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 46, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(objectCodec1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
assertSame(objectCodec1, objectCodec0);
// try {
readerBasedJsonParser0.nextLongValue(1164L);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000047; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test080() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
IOContext iOContext0 = new IOContext(bufferRecycler0, "2.2250738585072012e-308", true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
Object object0 = readerBasedJsonParser0.getObjectId();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext2 = new IOContext(bufferRecycler1, jsonEncoding0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertTrue(iOContext3.isResourceManaged());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = 'O';
charArray0[1] = 'O';
charArray0[2] = 'I';
charArray0[3] = 'I';
charArray0[4] = '*';
charArray0[5] = '*';
charArray0[6] = '*';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-984), stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 3, 2, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-984), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'O', 'O', 'I', 'I', '*', '*', '*'}, charArray0);
assertEquals(7, charArray0.length);
ObjectCodec objectCodec2 = readerBasedJsonParser0.getCodec();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(objectCodec2.equals((Object)objectCodec1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNotNull(objectCodec2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(objectCodec2, objectCodec0);
assertNotSame(objectCodec2, objectCodec1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
long long0 = readerBasedJsonParser0.nextLongValue(2);
assertEquals(2L, long0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext3);
assertNotSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
}
@Test(timeout = 4000)
public void test081() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("0ec`^Sa^f5a)");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocTokenBuffer(68);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 46, 3, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(4000, charArray0.length);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('c' (code 99)) in numeric value: Exponent indicator not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000048; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test082() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[9];
charArray0[0] = '/';
charArray0[1] = '/';
charArray0[2] = '-';
charArray0[3] = '/';
charArray0[4] = '/';
charArray0[5] = '/';
charArray0[6] = '/';
charArray0[7] = '/';
charArray0[8] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 54, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 54, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(54, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertArrayEquals(new char[] {'/', '/', '-', '/', '/', '/', '/', '/', '/'}, charArray0);
assertEquals(9, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('/', char0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(54, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertArrayEquals(new char[] {'/', '/', '-', '/', '/', '/', '/', '/', '/'}, charArray0);
assertEquals(9, charArray0.length);
assertSame(iOContext0, iOContext1);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('/' (code 47)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000049; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test083() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("/Qh=69GKH|m#");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 8, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000050; line: 2, column: 25]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test084() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000051; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test085() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("[C");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader2 = new StringReader("[C");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader2, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertEquals(3, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertEquals("[", jsonToken0.asString());
assertFalse(jsonToken0.isScalarValue());
assertTrue(jsonToken0.isStructStart());
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
JsonToken jsonToken1 = readerBasedJsonParser0._parsePosNumber(2);
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonToken1.equals((Object)jsonToken0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonToken1.isStructEnd());
assertEquals(7, jsonToken1.id());
assertTrue(jsonToken1.isNumeric());
assertFalse(jsonToken1.isBoolean());
assertNull(jsonToken1.asString());
assertFalse(jsonToken1.isStructStart());
assertTrue(jsonToken1.isScalarValue());
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(jsonToken1, jsonToken0);
}
@Test(timeout = 4000)
public void test086() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = '\t';
charArray0[1] = '\t';
charArray0[3] = '\t';
charArray0[4] = '#';
charArray0[5] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 46, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\t', '\t', '\u0000', '\t', '#', '#'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser0.nextLongValue((-605L));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('#' (code 35)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000052; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test087() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
long long1 = stringReader0.skip(1493L);
assertEquals(8L, long1);
assertFalse(long1 == long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
int int0 = stringReader0.read();
assertEquals((-1), int0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[3];
charArray0[0] = 'r';
charArray0[1] = 'r';
charArray0[2] = 'r';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 48, (-2797), true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'r', 'r', 'r'}, charArray0);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext1, (-933), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-933), (-2797), true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertNotNull(readerBasedJsonParser2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals((-933), readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'r', 'r', 'r'}, charArray0);
assertEquals(3, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser2.nextToken();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test088() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(975);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
int int0 = 224;
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer3.makeChild(224);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
charsToNameCanonicalizer4.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("OjAx3S5)v");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = '/';
charArray0[1] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4942), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 2, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-4942), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertArrayEquals(new char[] {'/', '/'}, charArray0);
assertEquals(2, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test089() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("null");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("null");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
assertEquals(JsonToken.FIELD_NAME, jsonToken0);
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertEquals(5, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
SerializedString serializedString0 = new SerializedString("null");
assertNotNull(serializedString0);
assertEquals(4, serializedString0.charLength());
assertEquals("null", serializedString0.toString());
assertEquals("null", serializedString0.getValue());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, serializedString0.charLength());
assertEquals("null", serializedString0.toString());
assertEquals("null", serializedString0.getValue());
assertNotSame(stringReader0, stringReader1);
JsonToken jsonToken1 = JsonToken.VALUE_FALSE;
assertEquals(JsonToken.VALUE_FALSE, jsonToken1);
assertFalse(jsonToken1.equals((Object)jsonToken0));
assertFalse(jsonToken1.isNumeric());
assertFalse(jsonToken1.isStructStart());
assertEquals("false", jsonToken1.asString());
assertTrue(jsonToken1.isScalarValue());
assertFalse(jsonToken1.isStructEnd());
assertTrue(jsonToken1.isBoolean());
assertEquals(10, jsonToken1.id());
assertNotSame(jsonToken1, jsonToken0);
}
@Test(timeout = 4000)
public void test090() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
String string0 = "~4O2;p]f4oc<<T";
StringReader stringReader0 = new StringReader("~4O2;p]f4oc<<T");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("~4O2;p]f4oc<<T");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[3];
charArray0[0] = '=';
charArray0[1] = '[';
charArray0[2] = 'b';
int int0 = stringReader1.read(charArray0);
assertEquals(3, int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertArrayEquals(new char[] {'~', '4', 'O'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0.nextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (';' (code 59)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000053; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test091() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]focT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
SerializedString serializedString0 = new SerializedString("DU4hhJ?IpAY\"");
assertNotNull(serializedString0);
assertEquals(12, serializedString0.charLength());
assertEquals("DU4hhJ?IpAY\"", serializedString0.toString());
assertEquals("DU4hhJ?IpAY\"", serializedString0.getValue());
char[] charArray0 = new char[8];
charArray0[0] = '0';
charArray0[1] = '#';
charArray0[2] = '%';
charArray0[3] = '$';
charArray0[4] = 'r';
charArray0[5] = '4';
charArray0[6] = '%';
charArray0[7] = '!';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 110, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'0', '#', '%', '$', 'r', '4', '%', '!'}, charArray0);
assertEquals(8, charArray0.length);
SerializedString serializedString1 = new SerializedString("DU4hhJ?IpAY\"");
assertTrue(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
assertEquals("DU4hhJ?IpAY\"", serializedString1.toString());
assertEquals("DU4hhJ?IpAY\"", serializedString1.getValue());
assertEquals(12, serializedString1.charLength());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('#' (code 35)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000054; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test092() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
SerializedString serializedString0 = new SerializedString("/sfMq[*<s|U-JOx");
assertNotNull(serializedString0);
assertEquals(15, serializedString0.charLength());
assertEquals("/sfMq[*<s|U-JOx", serializedString0.getValue());
assertEquals("/sfMq[*<s|U-JOx", serializedString0.toString());
IOContext iOContext2 = new IOContext(bufferRecycler0, "/sfMq[*<s|U-JOx", true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
StringReader stringReader0 = new StringReader("/sfMq[*<s|U-JOx");
assertNotNull(stringReader0);
char[] charArray0 = new char[4];
charArray0[0] = 'Q';
charArray0[1] = '0';
charArray0[2] = '#';
charArray0[3] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 3, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'Q', '0', '#', ']'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('#' (code 35)): Expected space separating root-level values
// // at [Source: java.lang.String@0000000055; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test093() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("+`");
assertNotNull(stringReader0);
SerializedString serializedString0 = new SerializedString("Illegal unquoted character (");
assertNotNull(serializedString0);
assertEquals(28, serializedString0.charLength());
assertEquals("Illegal unquoted character (", serializedString0.toString());
assertEquals("Illegal unquoted character (", serializedString0.getValue());
StringReader stringReader1 = new StringReader("Leading zeroes not allowed");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("04)$F+{DlE ");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader2, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
Integer integer0 = new Integer((-1255));
assertEquals((-1255), (int)integer0);
assertNotNull(integer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, "04)$F+{DlE ", true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Invalid numeric value: Leading zeroes not allowed
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000056; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test094() throws Throwable {
char[] charArray0 = new char[1];
charArray0[0] = 'd';
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("#*=]TWTQuH~N-/!E");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(java.lang.Class.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1131, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1131, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'d'}, charArray0);
assertEquals(1, charArray0.length);
Object object0 = readerBasedJsonParser0.getObjectId();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1131, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'d'}, charArray0);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(9);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
Class<Integer> class0 = Integer.class;
Integer integer0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNull(integer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1131, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'d'}, charArray0);
assertEquals(1, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
IOContext iOContext1 = new IOContext((BufferRecycler) null, (Object) null, false);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[19];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'P';
charArray1[1] = '?';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 53, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 9, (-832), true);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(53, readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(19, charArray1.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddName(497);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test095() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader2 = new StringReader("-Infinity");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-570), stringReader2, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(jsonToken0.isStructEnd());
assertEquals(8, jsonToken0.id());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000057; line: 1, column: 28]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test096() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[2];
charArray0[0] = 'i';
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1860, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1860, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1860, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isNumeric());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = null;
// try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1541, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test097() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader(" (version: ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2629, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2629, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(2);
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ByteArrayOutputStream byteArrayOutputStream0 = new ByteArrayOutputStream(2);
assertNotNull(byteArrayOutputStream0);
assertEquals(0, byteArrayOutputStream0.size());
assertEquals("", byteArrayOutputStream0.toString());
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayOutputStream0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test098() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("+`");
assertNotNull(stringReader0);
SerializedString serializedString0 = new SerializedString("Illegal unquoted character (");
assertNotNull(serializedString0);
assertEquals("Illegal unquoted character (", serializedString0.getValue());
assertEquals(28, serializedString0.charLength());
assertEquals("Illegal unquoted character (", serializedString0.toString());
StringReader stringReader1 = new StringReader(" (version: ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1140, stringReader1, objectCodec1, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1140, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(byteArrayBuilder0);
assertNotNull(objectOutputStream0);
assertEquals(4, byteArrayBuilder0.getCurrentSegmentLength());
byte[] byteArray0 = new byte[5];
byteArray0[2] = (byte) (-91);
byteArray0[3] = (byte)0;
byteArray0[4] = (byte)119;
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, objectOutputStream0, byteArray0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test099() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-255L));
assertEquals(0L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = stringReader0.read();
assertEquals(39, int0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NULL, jsonToken0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertEquals("null", jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertEquals(11, jsonToken0.id());
assertTrue(jsonToken0.isScalarValue());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
}
@Test(timeout = 4000)
public void test100() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("'null', 'true', 'false' or NaN");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-255L));
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = stringReader0.read();
assertEquals(39, int0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
char[] charArray0 = new char[1];
charArray0[0] = 'r';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 50, 1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertArrayEquals(new char[] {'r'}, charArray0);
assertEquals(1, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NULL, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertEquals("null", jsonToken0.asString());
assertFalse(jsonToken0.isStructStart());
assertEquals(11, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
}
@Test(timeout = 4000)
public void test101() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
charsToNameCanonicalizer2.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[6];
charArray0[0] = '/';
charArray0[1] = '/';
charArray0[2] = '/';
charArray0[3] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 3, 17, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertArrayEquals(new char[] {'/', '/', '/', '/', '\u0000', '\u0000'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)): was expecting either '*' or '/' for a comment
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000058; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test102() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
SerializedString serializedString0 = new SerializedString("/sfMq[*<s|U-JOx");
assertNotNull(serializedString0);
assertEquals("/sfMq[*<s|U-JOx", serializedString0.getValue());
assertEquals(15, serializedString0.charLength());
assertEquals("/sfMq[*<s|U-JOx", serializedString0.toString());
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader1, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
char[] charArray0 = new char[3];
charArray0[0] = 'Z';
charArray0[1] = '/';
charArray0[2] = '/';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 2, 3, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'Z', '/', '/'}, charArray0);
assertEquals(3, charArray0.length);
// try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('}' (code 125)): was expecting either '*' or '/' for a comment
// // at [Source: java.io.StringReader@0000000059; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test103() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("/");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("09Z`SQa5%");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
long long0 = stringReader2.skip(1999L);
assertEquals(9L, long0);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotSame(stringReader2, stringReader1);
assertNotSame(stringReader2, stringReader0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = stringReader1.read();
assertEquals(47, int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
StringReader stringReader3 = new StringReader("| ");
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertNotNull(stringReader3);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec0).toString();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1220), stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader3));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
Object object0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) null);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader3));
assertNull(object0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
assertNotSame(stringReader1, stringReader3);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader4 = new StringReader("09Z`SQa5%");
assertFalse(stringReader4.equals((Object)stringReader1));
assertFalse(stringReader4.equals((Object)stringReader3));
assertFalse(stringReader4.equals((Object)stringReader0));
assertFalse(stringReader4.equals((Object)stringReader2));
assertNotNull(stringReader4);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-2784), stringReader4, objectCodec1, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader4.equals((Object)stringReader1));
assertFalse(stringReader4.equals((Object)stringReader3));
assertFalse(stringReader4.equals((Object)stringReader0));
assertFalse(stringReader4.equals((Object)stringReader2));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals((-2784), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
// try {
readerBasedJsonParser1.nextLongValue(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Invalid numeric value: Leading zeroes not allowed
// // at [Source: UNKNOWN; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test104() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(java.lang.Class.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1731);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = ':';
charArray0[1] = '8';
charArray0[2] = 't';
charArray0[3] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3048, (Reader) null, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3048, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {':', '8', 't', 'D'}, charArray0);
assertEquals(4, charArray0.length);
Class<Integer> class0 = Integer.class;
Integer integer0 = readerBasedJsonParser0.readValueAs(class0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(integer0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3048, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {':', '8', 't', 'D'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
int int0 = (-2964);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 200, (Reader) null, objectCodec1, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser1.getFeatureMask());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test105() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("]- pycC*$");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3553, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3553, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000060; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test106() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(11);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = stringReader0.read();
assertEquals(117, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000061; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test107() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("9+`a");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('+' (code 43)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000062; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test108() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("I4jv,:'mRq");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "-ayD)S8ZM9EPM`F9<lt");
assertFalse(boolean0);
StringReader stringReader1 = new StringReader("&(\"d~IVSBU*(1JVK");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = 2126;
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[7];
charArray0[0] = 'C';
charArray0[1] = 'C';
charArray0[2] = 'C';
charArray0[3] = 'C';
charArray0[4] = 'C';
charArray0[5] = 'C';
charArray0[6] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2126, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 2, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2126, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertArrayEquals(new char[] {'C', 'C', 'C', 'C', 'C', 'C', 'C'}, charArray0);
assertEquals(7, charArray0.length);
String string0 = readerBasedJsonParser0._handleOddName('C');
assertEquals("C", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2126, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertArrayEquals(new char[] {'&', '(', '\"', 'd', '~', 'I', 'V'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._handleOddValue(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 2)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000063; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test109() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
charsToNameCanonicalizer2.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString(" ");
assertNotNull(serializedString0);
assertEquals(2, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-133), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-133), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(2, serializedString0.charLength());
assertEquals(" ", serializedString0.getValue());
assertEquals(" ", serializedString0.toString());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-133), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
readerBasedJsonParser0.nextToken();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-133), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
readerBasedJsonParser0.nextToken();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-133), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
}
@Test(timeout = 4000)
public void test110() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = 'a';
charArray0[1] = 'O';
charArray0[2] = 'O';
charArray0[3] = 'O';
charArray0[4] = 'O';
charArray0[5] = 'O';
charArray0[6] = 'O';
charArray0[7] = 'O';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 971, 663, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'a', 'O', 'O', 'O', 'O', 'O', 'O', 'O'}, charArray0);
assertEquals(8, charArray0.length);
ObjectCodec objectCodec0 = readerBasedJsonParser0.getCodec();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(objectCodec0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'a', 'O', 'O', 'O', 'O', 'O', 'O', 'O'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {' ', ' ', 'O', 'O', 'O', 'O', 'O', 'O'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {' ', ' ', 'O', 'O', 'O', 'O', 'O', 'O'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test111() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
SerializedString serializedString0 = new SerializedString("MRsBpWTEL`CfsgWezt");
assertNotNull(serializedString0);
assertEquals("MRsBpWTEL`CfsgWezt", serializedString0.getValue());
assertEquals(19, serializedString0.charLength());
assertEquals("MRsBpWTEL`CfsgWezt", serializedString0.toString());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000064; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test112() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[18];
charArray0[15] = ':';
charArray0[2] = ':';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(18, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(18, charArray0.length);
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000065; line: 2, column: 33]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test113() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
char[] charArray0 = new char[4];
charArray0[0] = ']';
charArray0[1] = 'i';
charArray0[2] = ']';
charArray0[3] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(4, int0);
assertArrayEquals(new char[] {'x', ')', 'u', ']'}, charArray0);
assertEquals(4, charArray0.length);
StringReader stringReader1 = new StringReader(",]``{;8nN0");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'i';
charArray1[1] = '9';
charArray1[2] = '9';
charArray1[3] = ']';
charArray1[4] = ']';
int int1 = stringReader0.read(charArray1);
assertEquals(5, int1);
assertFalse(int1 == int0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charArray1.equals((Object)charArray0));
assertArrayEquals(new char[] {'v', ':', 'K', 't', ' '}, charArray1);
assertEquals(5, charArray1.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charArray1, charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2079, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2079, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in a comment
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000066; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test114() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec0).toString();
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("/");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = stringReader0.read();
assertEquals(47, int0);
StringReader stringReader1 = new StringReader("| ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1220), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
TypeReference<Object> typeReference0 = (TypeReference<Object>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Object object0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1220), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
StringReader stringReader2 = new StringReader("/");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 51, stringReader2, objectCodec1, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertEquals(51, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in a comment
// // at [Source: UNKNOWN; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test115() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[2];
charArray0[0] = 'X';
charArray0[1] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(5);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
readerBasedJsonParser0._matchToken("-Infinity", 2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = null;
// try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer2);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test116() throws Throwable {
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, ":");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
int int0 = readerBasedJsonParser0.nextIntValue((-2));
assertEquals((-2), int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
}
@Test(timeout = 4000)
public void test117() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[2];
charArray0[0] = 'P';
charArray0[1] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
StringReader stringReader1 = new StringReader("INT");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '>';
int int1 = stringReader0.read(charArray1);
assertEquals(1, int1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(int1 == int0);
assertArrayEquals(new char[] {'n'}, charArray1);
assertEquals(1, charArray1.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charArray1, charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild((-128));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray1, 1113, 1, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'n'}, charArray1);
assertEquals(1, charArray1.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'finity': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000067; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test118() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, jsonEncoding0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
char[] charArray0 = iOContext2.allocConcatBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(charArray0);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(4000, charArray0.length);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
int int0 = stringReader0.read(charArray0);
assertEquals((-1), int0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(4000, charArray0.length);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF8;
IOContext iOContext3 = iOContext1.withEncoding(jsonEncoding2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertNotNull(iOContext3);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNotSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext3);
assertNotSame(jsonEncoding1, jsonEncoding2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext3);
assertSame(iOContext1, iOContext0);
assertSame(jsonEncoding2, jsonEncoding0);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(iOContext3, iOContext2);
assertSame(iOContext3, iOContext0);
assertSame(iOContext3, iOContext1);
StringReader stringReader1 = new StringReader("string value");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int1 = stringReader1.read();
assertEquals(115, int1);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(int1 == int0);
assertNotSame(stringReader1, stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext3, 1363, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding2));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(JsonEncoding.UTF8, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1363, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'tring': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000068; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test119() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("NaN");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("NaN");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token 'NaN': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000069; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test120() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader2 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
StringReader stringReader3 = new StringReader("NaN");
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertNotNull(stringReader3);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-271), stringReader3, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-271), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token 'NaN': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000070; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test121() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("n");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("n");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = '.';
charArray0[1] = 'a';
charArray0[2] = 'L';
charArray0[3] = 'c';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec1, charsToNameCanonicalizer3, charArray0, 729, 224, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertArrayEquals(new char[] {'.', 'a', 'L', 'c'}, charArray0);
assertEquals(4, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\n', char0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertArrayEquals(new char[] {'n', 'a', 'L', 'c'}, charArray0);
assertEquals(4, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
String string0 = readerBasedJsonParser0.getValueAsString((String) null);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNull(string0);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertArrayEquals(new char[] {'n', 'a', 'L', 'c'}, charArray0);
assertEquals(4, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0._parsePosNumber(42);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('n' (code 110)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000071; line: 1, column: 226]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test122() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("null");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2048, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(2048, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\n', char0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(2048, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(2048, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test123() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("[C");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader2 = new StringReader("[C");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader2, objectCodec0, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.START_ARRAY, jsonToken0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertEquals(3, jsonToken0.id());
assertFalse(jsonToken0.isScalarValue());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertEquals("[", jsonToken0.asString());
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000072; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test124() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[2];
charArray0[0] = 'X';
charArray0[1] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
StringReader stringReader1 = new StringReader("INT");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '>';
int int1 = stringReader0.read(charArray1);
assertEquals(1, int1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(int1 == int0);
assertArrayEquals(new char[] {'n'}, charArray1);
assertEquals(1, charArray1.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charArray1, charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 91, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'finity': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000073; line: 1, column: 13]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test125() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("[z v~A)4$CP'h#G");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("[z v~A)4$CP'h#G");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader3 = new StringReader("[z v~A)4$CP'h#G");
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(stringReader3);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = '>';
charArray0[1] = '>';
charArray0[2] = '2';
charArray0[3] = '>';
charArray0[4] = '>';
charArray0[5] = '1';
charArray0[6] = '>';
charArray0[7] = '>';
int int0 = stringReader2.read(charArray0);
assertEquals(8, int0);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader3));
assertFalse(stringReader2.equals((Object)stringReader0));
assertArrayEquals(new char[] {'[', 'z', ' ', 'v', '~', 'A', ')', '4'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(stringReader2, stringReader1);
assertNotSame(stringReader2, stringReader3);
assertNotSame(stringReader2, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer3);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader3));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(32, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader3, (ObjectCodec) null, charsToNameCanonicalizer3, charArray0, 33, 1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertArrayEquals(new char[] {'[', 'z', ' ', 'v', '~', 'A', ')', '4'}, charArray0);
assertEquals(8, charArray0.length);
String string0 = readerBasedJsonParser1.nextTextValue();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals(3, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser1.getCurrentToken());
assertTrue(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(2L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(3, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertArrayEquals(new char[] {'[', 'z', ' ', 'v', '~', 'A', ')', '4'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader3, stringReader0);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader1);
// try {
readerBasedJsonParser1._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000074; line: 1, column: 24]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test126() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
long long0 = stringReader0.skip((-3034L));
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1954), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1954), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
char char0 = readerBasedJsonParser0.getNextChar((String) null);
assertEquals('4', char0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1954), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
boolean boolean1 = readerBasedJsonParser0.loadMore();
assertFalse(boolean1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(boolean1 == boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-1954), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
String string0 = ":R`d;cdk_zg";
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(3, ":R`d;cdk_zg");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 3)): was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000075; line: 1, column: 18]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test127() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader(".@C%H\"q/\bYr*3.{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader(".@C%H\"q/\bYr*3.{");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
Integer integer0 = new Integer(2);
assertEquals(2, (int)integer0);
assertNotNull(integer0);
stringReader1.close();
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 97, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(97, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test128() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("t");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(byteArrayBuilder0);
assertNotNull(objectOutputStream0);
assertEquals(4, byteArrayBuilder0.getCurrentSegmentLength());
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, objectOutputStream0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test129() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[4];
charArray0[0] = ' ';
charArray0[1] = 'Y';
charArray0[2] = '%';
charArray0[1] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 255, 1, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {' ', ']', '%', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("Decimal point not followed by a digit");
assertNotNull(mockFileOutputStream0);
DataOutputStream dataOutputStream0 = new DataOutputStream(mockFileOutputStream0);
assertNotNull(dataOutputStream0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)67;
byteArray0[1] = (byte)121;
byteArray0[2] = (byte) (-67);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1625, (Reader) null, objectCodec1, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1625, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
String string0 = readerBasedJsonParser1.getValueAsString();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1625, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test130() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader1 = new StringReader("0Ur@<ht#UWk<g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'j';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader1, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3017, stringReader1, objectCodec0, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3017, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec1, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000076; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test131() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[4];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '9';
charArray1[1] = 'k';
charArray1[2] = '9';
charArray1[3] = 'N';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1919), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray1, 33, 0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1919), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'9', 'k', '9', 'N'}, charArray1);
assertEquals(4, charArray1.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000077; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test132() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader(" ");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader1 = new StringReader(" ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 413, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(413, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
long long0 = readerBasedJsonParser0.nextLongValue(2);
assertEquals(2L, long0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(413, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
int int0 = 53;
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(1);
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000078; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test133() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder();
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
ObjectOutputStream objectOutputStream0 = new ObjectOutputStream(byteArrayBuilder0);
assertNotNull(objectOutputStream0);
assertEquals(4, byteArrayBuilder0.getCurrentSegmentLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4920), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-4920), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
// Undeclared exception!
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, byteArrayBuilder0, byteArrayBuilder0.NO_BYTES);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test134() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2664);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = ' ';
charArray0[1] = 'Y';
charArray0[2] = '%';
charArray0[3] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3305), (Reader) null, objectCodec0, charsToNameCanonicalizer1, charArray0, 255, 1, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-3305), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {' ', 'Y', '%', ']'}, charArray0);
assertEquals(4, charArray0.length);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("Decimal point not followed by a digit");
assertNotNull(mockFileOutputStream0);
DataOutputStream dataOutputStream0 = new DataOutputStream(mockFileOutputStream0);
assertNotNull(dataOutputStream0);
byte[] byteArray0 = new byte[8];
byteArray0[0] = (byte)67;
byteArray0[1] = (byte)121;
byteArray0[2] = (byte) (-67);
byteArray0[3] = (byte)78;
byteArray0[4] = (byte)114;
byteArray0[5] = (byte)53;
byteArray0[6] = (byte)9;
byteArray0[7] = (byte)5;
// try {
readerBasedJsonParser0._readBinary((Base64Variant) null, dataOutputStream0, byteArray0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000079; line: 1, column: 257]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test135() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("7=5uZV#},Jzy[]w7+V");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-105), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-105), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(76);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString("7=5uZV#},Jzy[]w7+V");
assertNotNull(serializedString0);
assertEquals("7=5uZV#},Jzy[]w7+V", serializedString0.getValue());
assertEquals("7=5uZV#},Jzy[]w7+V", serializedString0.toString());
assertEquals(18, serializedString0.charLength());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('=' (code 61)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000080; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test136() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("7,tU]77v0");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 68, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(68, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (',' (code 44)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000081; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test137() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ObjectCodec objectCodec0 = null;
SerializedString serializedString0 = new SerializedString(") not VALUE_STRING, can not access as binary");
assertNotNull(serializedString0);
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.toString());
assertEquals(44, serializedString0.charLength());
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.getValue());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = " >0x";
StringReader stringReader0 = new StringReader(" >0x");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader(" >0x");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
// try {
readerBasedJsonParser0.nextLongValue(0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('>' (code 62)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000082; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test138() throws Throwable {
System.setCurrentTimeMillis((-2147483648L));
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("S)0k5n y");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(Integer.MAX_VALUE, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-907));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(Integer.MAX_VALUE, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(Integer.MAX_VALUE, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[7];
charArray0[0] = '?';
charArray0[1] = '@';
charArray0[2] = '\\';
charArray0[3] = '/';
charArray0[4] = '\"';
charArray0[5] = 'L';
charArray0[6] = '_';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 166, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 48, 9, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(166, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(Integer.MAX_VALUE, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(Integer.MAX_VALUE, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'?', '@', '\\', '/', '\"', 'L', '_'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized character escape 'S' (code 83)
// // at [Source: java.lang.Object@0000000083; line: 1, column: 11]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test139() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
String string0 = "I4jv,:'mRq";
StringReader stringReader0 = new StringReader("I4jv,:'mRq");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "-ayD)S8ZM9EPM`F9<lt");
assertFalse(boolean0);
StringReader stringReader1 = new StringReader("&(\"d~IVSBU*(1JVK");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 123, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(123, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[5];
charArray0[0] = 'Z';
charArray0[1] = '@';
charArray0[2] = 'f';
charArray0[3] = '(';
charArray0[4] = 'T';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 110, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 415, 2, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(110, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertArrayEquals(new char[] {'Z', '@', 'f', '(', 'T'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('4' (code 52)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000084; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test140() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("vhhLe$");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader1 = new StringReader("('true', 'false' or 'null')");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
StringReader stringReader2 = new StringReader("com.fasterxml.jackson.core.JsonProcessingException");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 1, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser1.nextIntValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test141() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("\"St ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("\"St ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader2 = new StringReader("D;xh Zg");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader2, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 65536, 33, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddValue(476);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test142() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("aJxfLY?'SvrY)r_W");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[9];
charArray0[0] = 'N';
charArray0[1] = ':';
charArray0[2] = 'B';
charArray0[3] = 'd';
charArray0[4] = 'Q';
charArray0[5] = '_';
charArray0[6] = 'v';
charArray0[7] = ' ';
charArray0[8] = '3';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 9, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 3, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(9, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'N', ':', 'B', 'd', 'Q', '_', 'v', ' ', '3'}, charArray0);
assertEquals(9, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddName(1000);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test143() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("INT");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = '>';
int int0 = stringReader0.read(charArray0);
assertEquals(1, int0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertArrayEquals(new char[] {'-'}, charArray0);
assertEquals(1, charArray0.length);
assertNotSame(stringReader0, stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000085; line: 1, column: 17]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test144() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("!4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
stringReader0.close();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-465), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-465), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test145() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("no");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("Illegal white space character (code 0x");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader2 = new StringReader("q/)B((JCKZsl!M(([");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
IOContext iOContext0 = new IOContext(bufferRecycler0, "\"St ", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, (-680), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-680), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 114, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 1, 69, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(114, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
// Undeclared exception!
// try {
readerBasedJsonParser1.nextIntValue(33);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test146() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}VAox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("8GPS&");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57343, stringReader1, objectCodec0, charsToNameCanonicalizer4);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(57343, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
boolean boolean1 = readerBasedJsonParser0.loadMore();
assertTrue(boolean1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(boolean1 == boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(57343, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('G' (code 71)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000086; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test147() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("expected padding character '");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("8");
assertNotNull(serializedString0);
assertEquals("8", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals("8", serializedString0.getValue());
IOContext iOContext0 = new IOContext(bufferRecycler0, "/sfMq[*<s|U-JOx", false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
char[] charArray0 = new char[7];
charArray0[0] = '/';
charArray0[1] = '/';
charArray0[2] = '/';
charArray0[3] = '/';
charArray0[4] = '/';
charArray0[5] = '/';
charArray0[6] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, (-3203), true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'/', '/', '/', '/', '/', '/', '/'}, charArray0);
assertEquals(7, charArray0.length);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals("8", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals("8", serializedString0.getValue());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3202), readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-3202L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'8', '/', '/', '/', '/', '/', '/'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-inputNo digit following minus sign
// // at [Source: java.lang.String@0000000087; line: 1, column: -3199]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test148() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "Q#T>";
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#T>", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1556));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString("Q#T>");
assertNotNull(serializedString0);
assertEquals("Q#T>", serializedString0.getValue());
assertEquals(4, serializedString0.charLength());
assertEquals("Q#T>", serializedString0.toString());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: java.lang.String@0000000010; line: 1, column: 0])
// // at [Source: java.lang.String@0000000088; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test149() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
String string0 = "}'!_4";
StringReader stringReader0 = new StringReader("}'!_4");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000089; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test150() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("x)u]v:mt /");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2502, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2502, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
long long1 = readerBasedJsonParser0._nameStartOffset;
assertEquals(0L, long1);
assertFalse(long1 == long0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(object0.equals((Object)stringReader1));
assertNotNull(object0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2502, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotSame(stringReader0, stringReader1);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(object0, stringReader1);
assertSame(object0, stringReader0);
// try {
readerBasedJsonParser0._matchToken("x)u]v:mt /", 3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test151() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("1");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString("1");
assertNotNull(serializedString0);
assertEquals("1", serializedString0.toString());
assertEquals("1", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals("1", serializedString0.toString());
assertEquals("1", serializedString0.getValue());
assertEquals(1, serializedString0.charLength());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer2, (char[]) null, 1, (-1202), true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
JsonToken jsonToken0 = readerBasedJsonParser0._parsePosNumber(0);
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test152() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 46, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
readerBasedJsonParser0.nextToken();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer3);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
// try {
readerBasedJsonParser1._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test153() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader0 = new StringReader("=ivCZ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer4);
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
long long0 = stringReader0.skip(2438L);
assertEquals(5L, long0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(33);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer3, charArray0, 0, 224, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(200, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 200
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test154() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
String string0 = "1";
StringReader stringReader0 = new StringReader("1");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("1");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader1, objectCodec0, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
readerBasedJsonParser0.nextToken();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec1, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
// try {
readerBasedJsonParser1._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000090; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test155() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("8GPS&");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = 'a';
charArray0[1] = '\"';
charArray0[2] = '4';
charArray0[3] = '{';
charArray0[4] = 'N';
charArray0[5] = 'h';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 83, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'a', '\"', '4', '{', 'N', 'h'}, charArray0);
assertEquals(6, charArray0.length);
JsonToken jsonToken0 = JsonToken.START_OBJECT;
assertEquals(JsonToken.START_OBJECT, jsonToken0);
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isNumeric());
assertEquals(1, jsonToken0.id());
assertEquals("{", jsonToken0.asString());
readerBasedJsonParser0._skipString();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'a', '\"', '4', '{', 'N', 'h'}, charArray0);
assertEquals(6, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('{' (code 123)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000091; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test156() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("9XU{:<EEw");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "9XU{:<EEw", true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4906);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
stringReader0.close();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3160, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3160, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(73, "9XU{:<EEw");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test157() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("1F");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-948), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-948), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-948), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('F' (code 70)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000092; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test158() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("1");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
SerializedString serializedString0 = new SerializedString("1");
assertNotNull(serializedString0);
assertEquals("1", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals("1", serializedString0.getValue());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals("1", serializedString0.toString());
assertEquals(1, serializedString0.charLength());
assertEquals("1", serializedString0.getValue());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, int0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNull(object0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test159() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[6];
charArray0[0] = '|';
charArray0[1] = '9';
charArray0[2] = 'M';
charArray0[3] = '<';
charArray0[4] = 'h';
charArray0[5] = '|';
int int0 = stringReader0.read(charArray0);
assertEquals((-1), int0);
assertArrayEquals(new char[] {'|', '9', 'M', '<', 'h', '|'}, charArray0);
assertEquals(6, charArray0.length);
Integer integer0 = new Integer((-1132));
assertEquals((-1132), (int)integer0);
assertFalse(integer0.equals((Object)int0));
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(integer0.equals((Object)int0));
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2000, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 2, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(integer0.equals((Object)int0));
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'|', '9', 'M', '<', 'h', '|'}, charArray0);
assertEquals(6, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._parsePosNumber(1821);
assertEquals(JsonToken.VALUE_NUMBER_INT, jsonToken0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(integer0.equals((Object)int0));
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(jsonToken0.isStructEnd());
assertEquals(7, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertArrayEquals(new char[] {'|', '9', 'M', '<', 'h', '|'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: java.lang.Integer@0000000093; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test160() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "4B)";
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = stringReader0.read();
assertEquals(41, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3096), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
String string1 = "";
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int1 = 85;
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-494));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 53, stringReader0, objectCodec1, charsToNameCanonicalizer1, (char[]) null, 2873, 101, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(53, readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 127)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000094; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test161() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
IOContext iOContext1 = new IOContext(bufferRecycler0, "t", true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("}\"0V8].A");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2365), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals((-2365), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
readerBasedJsonParser0._finishString();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals((-2365), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(iOContext0, iOContext1);
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("Q#+T>.", "SpgGr, yxLo/", false, 'N', (-2));
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 12)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test162() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("{.dBq?9f");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("jRc,!zVzLxO_I)");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 110, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(110, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(110, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(JsonToken.START_OBJECT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(stringReader0, stringReader1);
// try {
readerBasedJsonParser0._parsePosNumber(45);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('d' (code 100)) in numeric value: Decimal point not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000095; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test163() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("epTU6jDM@8");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[5];
charArray0[0] = 'h';
charArray0[1] = '<';
charArray0[2] = 'Q';
charArray0[3] = '|';
charArray0[3] = 'M';
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'e', 'p', 'T', 'U', '6'}, charArray0);
assertEquals(5, charArray0.length);
Integer integer0 = new Integer(91);
assertEquals(91, (int)integer0);
assertFalse(integer0.equals((Object)int0));
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(integer0.equals((Object)int0));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 3, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(integer0.equals((Object)int0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'e', 'p', 'T', 'U', '6'}, charArray0);
assertEquals(5, charArray0.length);
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.configure(jsonParser_Feature0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(integer0.equals((Object)int0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(131, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(131, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'e', 'p', 'T', 'U', '6'}, charArray0);
assertEquals(5, charArray0.length);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
int int1 = 2283;
// try {
readerBasedJsonParser0._parsePosNumber(2283);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('p' (code 112)) in numeric value: Exponent indicator not followed by a digit
// // at [Source: java.lang.Integer@0000000096; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test164() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[4];
charArray0[2] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 93, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'\u0000', '\u0000', '.', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber((-32));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)) in numeric value: Decimal point not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000097; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test165() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
JsonToken jsonToken0 = readerBasedJsonParser0._parseNegNumber();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(jsonToken0.isStructEnd());
assertEquals(8, jsonToken0.id());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
readerBasedJsonParser0.nextToken();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test166() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3058, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3058, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
char[] charArray0 = new char[9];
charArray0[0] = 'r';
charArray0[1] = '{';
charArray0[2] = '8';
charArray0[3] = 't';
charArray0[4] = '_';
charArray0[5] = ']';
charArray0[6] = 'g';
charArray0[7] = '!';
charArray0[8] = 'B';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 80, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 97, 1717, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(80, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'r', '{', '8', 't', '_', ']', 'g', '!', 'B'}, charArray0);
assertEquals(9, charArray0.length);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3058, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
}
@Test(timeout = 4000)
public void test167() throws Throwable {
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = stringReader0.read();
assertEquals(52, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_FLOAT;
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
Object object0 = null;
IOContext iOContext0 = new IOContext(bufferRecycler0, "4B)", true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[8];
charArray0[0] = '%';
charArray0[1] = 'J';
charArray0[2] = '9';
charArray0[3] = '3';
charArray0[4] = 'l';
charArray0[5] = '#';
charArray0[6] = 't';
charArray0[7] = 'Y';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 3, 28, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertArrayEquals(new char[] {'%', 'J', '9', '3', 'l', '#', 't', 'Y'}, charArray0);
assertEquals(8, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('l' (code 108)): Expected space separating root-level values
// // at [Source: java.lang.String@0000000098; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test168() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Ininity");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
int int0 = stringReader0.read();
assertEquals(45, int0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
StringReader stringReader2 = new StringReader("3 c0N&trg47\"3+%E,");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
SerializedString serializedString0 = new SerializedString("W<-(%_K");
assertNotNull(serializedString0);
assertEquals("W<-(%_K", serializedString0.toString());
assertEquals("W<-(%_K", serializedString0.getValue());
assertEquals(7, serializedString0.charLength());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(7, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.VALUE_NUMBER_INT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals("W<-(%_K", serializedString0.toString());
assertEquals("W<-(%_K", serializedString0.getValue());
assertEquals(7, serializedString0.charLength());
assertNotSame(stringReader2, stringReader1);
assertNotSame(stringReader2, stringReader0);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000099; line: 1, column: 35]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test169() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("5i)cYm]rq");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
stringReader0.close();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 92, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(92, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0._skipCR();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test170() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
char[] charArray0 = new char[4];
charArray0[0] = '\u001E';
charArray0[1] = ':';
charArray0[2] = '\u001E';
charArray0[2] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, true);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'\u001E', ':', ':', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'\u001E', ':', ':', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 30)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000100; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test171() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("0ec`^Sa^f5a)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 942, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(942, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 942, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 3, 44, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(942, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
// Undeclared exception!
// try {
readerBasedJsonParser1.loadMore();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test172() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte) (-31);
byteArray0[1] = (byte)5;
byteArray0[2] = (byte)122;
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte) (-31), (byte)5, (byte)122}, byteArray0);
assertEquals(3, byteArray0.length);
StringReader stringReader0 = new StringReader("expected padding character '");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser0.getNextChar("expected padding character '");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test173() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("n");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("n");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[2];
charArray0[0] = '\"';
charArray0[1] = 'C';
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(2000, byteArray0.length);
assertSame(iOContext0, iOContext1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 3, 1, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'\"', 'C'}, charArray0);
assertEquals(2, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'n', 'C'}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000101; line: 2, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test174() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0.getText();
assertEquals(":", string1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
String string2 = readerBasedJsonParser0.getValueAsString("s[uMhU");
assertEquals(":", string2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string2.equals((Object)string0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (':' (code 58)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000102; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test175() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString("");
assertNotNull(serializedString0);
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals("", serializedString0.toString());
assertEquals("", serializedString0.getValue());
assertEquals(0, serializedString0.charLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, int0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNull(object0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
readerBasedJsonParser0._releaseBuffers();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test176() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("Null String illegal for SerializedSting");
assertNotNull(stringReader0);
char[] charArray0 = new char[0];
int int0 = stringReader0.read(charArray0);
assertEquals(0, int0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
StringReader stringReader1 = new StringReader("2mi3DhEWy~-WWgZSPRr");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int1 = stringReader1.read(charArray0);
assertEquals(0, int1);
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(int1 == int0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('m' (code 109)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000103; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test177() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O|24;p]f4ocT%<");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
byte[] byteArray0 = iOContext0.allocReadIOBuffer(52);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000104; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test178() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
String string0 = "4)O24;p]f4ocT<<\\";
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000105; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test179() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("\"m");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
String string0 = null;
String string1 = readerBasedJsonParser0._parseName();
assertEquals("", string1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNotSame(stringReader1, stringReader0);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("*0}Vox|1]", 57);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test180() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("^c+H");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int1 = (-314);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-314), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-314), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000106; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test181() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "*0}Vox|1]";
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("8GPS&");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader2 = new StringReader("*0}Vox|1]");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = '1';
boolean boolean0 = false;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader2, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 51, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'1'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test182() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[18];
charArray0[15] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 6, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(18, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(18, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-558));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-569), stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 250, 3022, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals((-569), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(18, charArray0.length);
ObjectCodec objectCodec2 = readerBasedJsonParser0.getCodec();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(objectCodec2.equals((Object)objectCodec1));
assertNotNull(objectCodec2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(18, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(objectCodec2, objectCodec0);
assertNotSame(objectCodec2, objectCodec1);
// try {
readerBasedJsonParser0.nextLongValue(33);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000107; line: 2, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test183() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1469, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 2, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1469, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, "Fdv7", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, objectCodec2, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser2);
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
String string0 = readerBasedJsonParser2.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(string0);
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser2.getFeatureMask());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser0);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(iOContext1, iOContext0);
Boolean boolean1 = readerBasedJsonParser1.nextBooleanValue();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser2));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(2, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1L, readerBasedJsonParser1.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertTrue(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1469, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(6, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser2);
// try {
readerBasedJsonParser1.getValueAsString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000108; line: 1, column: 23]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test184() throws Throwable {
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-550));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
boolean boolean2 = false;
char[] charArray0 = new char[1];
charArray0[0] = 'H';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, (-550), false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'H'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0.getNextChar("");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000109; line: 1, column: -548]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test185() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0.nextTextValue();
assertEquals(":", string1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(string1.equals((Object)string0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1339));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (':' (code 58)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000110; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test186() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("'f3?palvy");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
boolean boolean0 = stringReader1.markSupported();
assertTrue(boolean0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertNotSame(stringReader1, stringReader0);
boolean boolean1 = readerBasedJsonParser0.loadMore();
assertFalse(boolean1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(boolean1 == boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0.readBinaryValue((Base64Variant) null, (OutputStream) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000111; line: 1, column: 11]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test187() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader1 = new StringReader("true");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = iOContext0.allocNameCopyBuffer(1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
assertNotSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 92, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(92, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0.readBinaryValue((Base64Variant) null, (OutputStream) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000112; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test188() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader1 = new StringReader("9XU{:<ELw");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2912, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, Integer.MAX_VALUE, 0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2912, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2912, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: UNKNOWN; line: 2, column: 14]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test189() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(3);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[5];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1408), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 33, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-1408), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer1, charArray0, 33, 2, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in name
// // at [Source: java.lang.String@0000000113; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test190() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("' (for ");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(1);
assertEquals(1L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("Invalid numeric value: ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = stringReader1.read();
assertEquals(73, int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
byte[] byteArray0 = iOContext1.allocBase64Buffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(byteArray0);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(2000, byteArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer3.makeChild((-383));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer4);
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(string0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(stringReader1, stringReader0);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 52, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(52, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
// try {
readerBasedJsonParser1._handleOddValue(43);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (' ' (code 32)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000114; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test191() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
StringReader stringReader0 = new StringReader("+rbIEj6j$$\"0#RMTPTO");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
char[] charArray0 = new char[1];
charArray0[0] = '_';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1351, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 48, 2, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1351, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertArrayEquals(new char[] {'_'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('r' (code 114)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000115; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test192() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("tf>T{yu\"'ATx*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = '5';
charArray0[1] = 'z';
charArray0[2] = 'g';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 826, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, 45, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(826, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'5', 'z', 'g'}, charArray0);
assertEquals(3, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('z' (code 122)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000116; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test193() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("0Ur@<ht#UWk<g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'j';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, (-2476), (-2261), true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'j'}, charArray0);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1910);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
boolean boolean0 = readerBasedJsonParser0.loadMore();
assertTrue(boolean0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'0'}, charArray0);
assertEquals(1, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader1, stringReader0);
StringReader stringReader2 = new StringReader("0Ur@<ht#UWk<g");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2096, stringReader1, objectCodec1, charsToNameCanonicalizer1, charArray0, 116, 0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(2096, readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertArrayEquals(new char[] {'0'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._parsePosNumber(0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test194() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("Meo<MyZ@4]&");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 108, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(108, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000117; line: 1, column: 23]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test195() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[23];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocTokenBuffer();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, true);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(23, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0.getValueAsString();
assertEquals(":", string1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string2 = readerBasedJsonParser0.getValueAsString();
assertEquals(":", string2);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string2.equals((Object)string0));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string3 = readerBasedJsonParser0.getText();
assertEquals(":", string3);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string3.equals((Object)string0));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string3);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string4 = readerBasedJsonParser0.getValueAsString();
assertEquals(":", string4);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string4.equals((Object)string0));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string4);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(jsonLocation0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(3L, jsonLocation0.getCharOffset());
assertEquals(4, jsonLocation0.getColumnNr());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
char[] charArray2 = readerBasedJsonParser0.getTextCharacters();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(charArray2.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(charArray2);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(23, charArray0.length);
assertEquals(23, charArray2.length);
assertSame(charArray0, charArray2);
assertNotSame(charArray0, charArray1);
assertNotSame(charArray2, charArray1);
assertSame(charArray2, charArray0);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test196() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[23];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocTokenBuffer();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, true);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(23, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(1, int0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(23, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals(0L, jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(23, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test197() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
String string0 = "4B_9)";
StringReader stringReader0 = new StringReader("4B_9)");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader1 = new StringReader("9+`a");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = null;
char[] charArray0 = new char[1];
charArray0[0] = 'd';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 98, 12, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'d'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('+' (code 43)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000118; line: 1, column: 15]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test198() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
SerializedString serializedString0 = new SerializedString(") not VALUE_STRING, can not access as binary");
assertNotNull(serializedString0);
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.toString());
assertEquals(44, serializedString0.charLength());
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.getValue());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader(" / 0x");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('/' (code 47)): maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000119; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test199() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ObjectCodec objectCodec0 = null;
SerializedString serializedString0 = new SerializedString(") not VALUE_STRING, can not access as binary");
assertNotNull(serializedString0);
assertEquals(44, serializedString0.charLength());
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.getValue());
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.toString());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = " / 0x";
StringReader stringReader0 = new StringReader(" / 0x");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader(" / 0x");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextLongValue(0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('/' (code 47)): maybe a (non-standard) comment? (not recognized as one since Feature 'ALLOW_COMMENTS' not enabled for parser)
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000120; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test200() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = stringReader0.read();
assertEquals(117, int0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 391, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(391, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000121; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test201() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocConcatBuffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 4
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test202() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, "com.fasterxml.jackson.core.JsonToken", false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("+");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1660), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-1660), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in a value
// // at [Source: java.lang.String@0000000122; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test203() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
SerializedString serializedString0 = new SerializedString(") not VALUE_STRING, can not access as binary");
assertNotNull(serializedString0);
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.toString());
assertEquals(44, serializedString0.charLength());
assertEquals(") not VALUE_STRING, can not access as binary", serializedString0.getValue());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("+");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-10), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-10), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in a value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000123; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test204() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[23];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocTokenBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, true);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(23, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0.getValueAsString();
assertEquals(":", string1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(1, int0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(jsonLocation0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0L, jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(23, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test205() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
Object object0 = new Object();
assertNotNull(object0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertFalse(boolean0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(boolean0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(5, int0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test206() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(290);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
charsToNameCanonicalizer3.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer3);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '+INF': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000124; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test207() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "+h>.", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("+h>.");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext1, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 110, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(110, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('h' (code 104)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.io.IOContext@0000000125; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test208() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("+INF");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 69, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(69, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '+INF': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000126; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test209() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals((-1), int0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("n!wiO-( n)ZxuG3U(");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1332), stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-1332), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000127; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test210() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
charArray0[0] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
SerializedString serializedString0 = new SerializedString("4$Ijw'&hx");
assertNotNull(serializedString0);
assertEquals(9, serializedString0.charLength());
assertEquals("4$Ijw'&hx", serializedString0.getValue());
assertEquals("4$Ijw'&hx", serializedString0.toString());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-822), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 49, (-842), true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals((-822), readerBasedJsonParser1.getFeatureMask());
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
// try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'nfinity': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000128; line: 1, column: -833]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test211() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("\"(@_thbofb^\"FC-y<q/");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("\"(@_thbofb^\"FC-y<q/");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
long long0 = stringReader1.skip(3597L);
assertEquals(19L, long0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader2 = new StringReader("q");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
int int0 = stringReader1.read();
assertEquals((-1), int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-814), stringReader0, objectCodec0, charsToNameCanonicalizer4);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-814), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
char char0 = readerBasedJsonParser0.getNextChar("\"(@_thbofb^\"FC-y<q/");
assertEquals('\"', char0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-814), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
char char1 = readerBasedJsonParser0.getNextChar("H$V");
assertEquals('(', char1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(char1 == char0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-814), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
}
@Test(timeout = 4000)
public void test212() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("8GPS&");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader0, objectCodec0, charsToNameCanonicalizer3);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = '&';
charArray0[1] = 'D';
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-852), stringReader0, objectCodec2, charsToNameCanonicalizer0, charArray0, 33, 7, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals((-852), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'&', 'D'}, charArray0);
assertEquals(2, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1._releaseBuffers();
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test213() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("\"(@_thbofb^\"FC-y<q/");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(73);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 47, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\"', char0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000129; line: 1, column: 39]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test214() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("\"St ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
char[] charArray0 = new char[4];
charArray0[0] = 'u';
charArray0[1] = '8';
charArray0[2] = ',';
charArray0[3] = 'T';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2, (-1822), false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'u', '8', ',', 'T'}, charArray0);
assertEquals(4, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\"', char0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
StringReader stringReader1 = new StringReader("\"St ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
}
@Test(timeout = 4000)
public void test215() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B_9)");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader1 = new StringReader("9+`a");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32752, stringReader1, objectCodec0, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32752, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32752, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('+' (code 43)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000130; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test216() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9+`a");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 37, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(37, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(37, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('+' (code 43)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000131; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test217() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "*0}Vox|1]";
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("\"m");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(127, "*0}Vox|1]");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('\"' (code 34)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000132; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test218() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
char[] charArray0 = iOContext0.allocNameCopyBuffer(1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
char[] charArray1 = new char[6];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '5';
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
charArray1[1] = '<';
charArray1[2] = '';
charArray1[3] = '>';
charArray1[4] = '/';
charArray1[5] = '';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3604, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 0, 33, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(3604, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'5', '<', '', '>', '/', ''}, charArray1);
assertEquals(6, charArray1.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000133; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test219() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(8);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("5i)cYm]rq");
assertNotNull(stringReader0);
char[] charArray0 = new char[9];
charArray0[0] = '';
charArray0[1] = '/';
charArray0[2] = 'K';
SerializedString serializedString0 = new SerializedString("5i)cYm]rq");
assertNotNull(serializedString0);
assertEquals("5i)cYm]rq", serializedString0.toString());
assertEquals("5i)cYm]rq", serializedString0.getValue());
assertEquals(9, serializedString0.charLength());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 53, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(53, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('i' (code 105)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000134; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test220() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = 'I';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'I', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
readerBasedJsonParser0.close();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'I', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in a value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000135; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test221() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(97);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString(": was expecting closing quote for a string value");
assertNotNull(serializedString0);
assertEquals(": was expecting closing quote for a string value", serializedString0.toString());
assertEquals(": was expecting closing quote for a string value", serializedString0.getValue());
assertEquals(48, serializedString0.charLength());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000136; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test222() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("}'!_4");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1953, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1953, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
SerializedString serializedString0 = new SerializedString("}'!_4");
assertNotNull(serializedString0);
assertEquals("}'!_4", serializedString0.toString());
assertEquals(6, serializedString0.charLength());
assertEquals("}'!_4", serializedString0.getValue());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000137; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test223() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, "vRXWH", true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4868);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 158, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(158, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
boolean boolean1 = readerBasedJsonParser0.loadMore();
assertTrue(boolean1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean1 == boolean0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(158, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// Undeclared exception!
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(4868, "9XU{:<ELw");
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test224() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, "vRXWH", true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4868);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 158, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(158, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
boolean boolean1 = readerBasedJsonParser0.loadMore();
assertTrue(boolean1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(boolean1 == boolean0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(158, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// Undeclared exception!
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(4868, "9XU{:<ELw");
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test225() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("8GPS&");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer4);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
boolean boolean1 = readerBasedJsonParser0.loadMore();
assertTrue(boolean1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean1 == boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
// Undeclared exception!
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(127, "C{Ew/?;b~KB&`aO73n");
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test226() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(48);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 42, (Reader) null, objectCodec0, charsToNameCanonicalizer2);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(42, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(0, int0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(42, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0._handleOddName(127);
assertEquals("", string0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(42, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._handleOddValue(0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000138; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test227() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("5i)cYm]rq");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 92, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(92, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(92, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('i' (code 105)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000139; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test228() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("8GPS&");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer3);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('G' (code 71)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000140; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test229() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
String string0 = "}_liH$?B:";
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("}_liH$?B:");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3214), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 98, (-405), true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-3214), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test230() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("\"St ");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000141; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test231() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocConcatBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string1 = readerBasedJsonParser0.getValueAsString();
assertEquals(":", string1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string2 = readerBasedJsonParser0.getText();
assertEquals(":", string2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string2.equals((Object)string0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string2);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test232() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = 37;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(37);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("5i)cYm]rq");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[9];
charArray0[0] = '@';
charArray0[1] = 'U';
charArray0[2] = '';
charArray0[3] = 'p';
charArray0[4] = '/';
charArray0[5] = 'q';
charArray0[6] = 'T';
charArray0[7] = 'K';
charArray0[8] = 'Q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 37, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 613, (-2055), false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(37, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertArrayEquals(new char[] {'@', 'U', '', 'p', '/', 'q', 'T', 'K', 'Q'}, charArray0);
assertEquals(9, charArray0.length);
String string0 = readerBasedJsonParser0.getText();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(37, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertArrayEquals(new char[] {'@', 'U', '', 'p', '/', 'q', 'T', 'K', 'Q'}, charArray0);
assertEquals(9, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('i' (code 105)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000142; line: 1, column: -2052]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test233() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(93);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[21];
charArray0[0] = 's';
charArray0[1] = '?';
charArray0[2] = '/';
charArray0[3] = '1';
charArray0[4] = 'B';
charArray0[5] = '>';
charArray0[6] = 'C';
charArray0[7] = 'G';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, (-3121), true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(21, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructStart());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(21, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("true", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(21, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test234() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
charArray0[1] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\u0000', 'C'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(charArray1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
long long0 = readerBasedJsonParser0.nextLongValue(3);
assertEquals(3L, long0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string1 = readerBasedJsonParser0.getValueAsString();
assertEquals("true", string1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test235() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = '<';
charArray0[1] = 'U';
charArray0[2] = '>';
charArray0[3] = '`';
charArray0[4] = 'D';
charArray0[5] = 'z';
int int0 = stringReader2.read(charArray0);
assertEquals(6, int0);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertArrayEquals(new char[] {'_', '&', 'x', '', '1', '6'}, charArray0);
assertEquals(6, charArray0.length);
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1, 2, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test236() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("6x4B_9)");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec0).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(550);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[5];
charArray0[0] = 'g';
charArray0[1] = '5';
charArray0[2] = 'V';
charArray0[3] = ')';
charArray0[4] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 12, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 33, 3, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(12, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'g', '5', 'V', ')', 'q'}, charArray0);
assertEquals(5, charArray0.length);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(treeNode0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(12, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'g', '5', 'V', ')', 'q'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 2254, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(2254, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
char[] charArray1 = iOContext1.allocNameCopyBuffer(33);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(charArray1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(200, charArray1.length);
assertNotSame(charArray1, charArray0);
assertNotSame(iOContext1, iOContext0);
StringReader stringReader1 = new StringReader("6x4B_9)");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild((-1008));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, 2, stringReader1, objectCodec2, charsToNameCanonicalizer3, charArray0, 101, 0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertArrayEquals(new char[] {'g', '5', 'V', ')', 'q'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser2.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('x' (code 120)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000143; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test237() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = ':';
ObjectCodec objectCodec1 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1570), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-1570), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
boolean boolean0 = stringReader0.ready();
assertTrue(boolean0);
boolean boolean1 = stringReader0.markSupported();
assertTrue(boolean1);
assertTrue(boolean1 == boolean0);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('4', char0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-1570), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000144; line: 1, column: 33]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test238() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(34);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(123);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
char[] charArray0 = iOContext0.allocTokenBuffer();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer2, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader(" Z~9Y0E7{];~up");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec0).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec0).toString();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 102, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNull(treeNode0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(102, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 33, (Reader) null, objectCodec1, charsToNameCanonicalizer3, charArray0, 2004, 3, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(4000, charArray0.length);
SerializedString serializedString0 = new SerializedString(" Z~9Y0E7{];~up");
assertNotNull(serializedString0);
assertEquals(" Z~9Y0E7{];~up", serializedString0.getValue());
assertEquals(" Z~9Y0E7{];~up", serializedString0.toString());
assertEquals(14, serializedString0.charLength());
// Undeclared exception!
// try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Trying to release buffer not owned by the context
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test239() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[5];
charArray0[0] = 'b';
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 119, 53, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'b', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'b', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(object0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'b', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'b', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test240() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("8GPS&");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer3);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(127, "C{Ew/?;b~KB&`aO73n");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('&' (code 38)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000145; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test241() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("t");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
assertSame(iOContext0, iOContext1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\t', char0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("", string0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
int int0 = readerBasedJsonParser0.getTextOffset();
assertEquals(0, int0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(stringReader0, object0);
assertSame(object0, stringReader0);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1L, jsonLocation0.getCharOffset());
assertEquals(2, jsonLocation0.getColumnNr());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(stringReader0, object0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(stringReader0, object0);
}
@Test(timeout = 4000)
public void test242() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
charArray0[1] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\u0000', 'C'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertEquals(6, jsonToken0.id());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('\t', char0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'t', 'r'}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
assertFalse(boolean1 == boolean0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'t', 'r'}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'rue': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000146; line: 1, column: -3060]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test243() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader(".gR$XMJ5E~ib&");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader1 = new StringReader("7;?'");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2947, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2947, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (';' (code 59)): Expected space separating root-level values
// // at [Source: java.lang.String@0000000147; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test244() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader0 = new StringReader("@-[VO");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
charArray0[0] = '7';
charArray0[1] = 'Z';
charArray0[2] = ')';
charArray0[3] = '3';
charArray0[4] = 'T';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 52, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'7', 'Z', ')', '3', 'T'}, charArray0);
assertEquals(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'7', 'Z', ')', '3', 'T'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('Z' (code 90)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000148; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test245() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(3);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("\"w44Y)C");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader2 = new StringReader("WbN`");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-117), stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-117), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-117), readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(jsonLocation0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals((-117), readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals(0L, jsonLocation0.getCharOffset());
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000149; line: 1, column: 15]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test246() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("'null', 'true, 'fase' or NaN");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(16);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 16, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
long long0 = readerBasedJsonParser0.nextLongValue(2);
assertEquals(2L, long0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals("null", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test247() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocConcatBuffer();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string1 = readerBasedJsonParser0.getValueAsString();
assertEquals(":", string1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test248() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
char[] charArray0 = iOContext0.allocNameCopyBuffer(1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(200, charArray0.length);
assertSame(iOContext0, iOContext1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'v';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray1, 1, 6, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertArrayEquals(new char[] {'v'}, charArray1);
assertEquals(1, charArray1.length);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000150; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test249() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("L#aV|xlTY^aV");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
stringReader0.close();
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test250() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
char[] charArray0 = bufferRecycler0.allocCharBuffer(2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(charArray0);
assertEquals(200, charArray0.length);
char[] charArray1 = new char[4];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = ';';
charArray1[1] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray1, 0, 2, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {';', ')', '\u0000', '\u0000'}, charArray1);
assertEquals(4, charArray1.length);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000151; line: 1, column: 43]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test251() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = stringReader0.read();
assertEquals(117, int0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("^'d_M,ThK;5");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[3];
charArray0[0] = 'T';
charArray0[2] = '7';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, 1, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'T', '\u0000', '7'}, charArray0);
assertEquals(3, charArray0.length);
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("T^", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertTrue(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'^', '\'', 'd'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test252() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 43, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, 0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(43, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser0.loadMore();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test253() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("Ag 4NQy7T");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
long long0 = stringReader0.skip(3);
assertEquals(3L, long0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 217, stringReader1, objectCodec0, charsToNameCanonicalizer3);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
String string0 = readerBasedJsonParser0.getCurrentName();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(217, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(127, "C{Ew/?;b~KB&`aO73n");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('4' (code 52)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000152; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test254() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("JR3yC{l_b[j[");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(260);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[7];
charArray0[0] = 'p';
charArray0[1] = 'c';
charArray0[2] = ':';
charArray0[3] = '`';
charArray0[4] = 'R';
charArray0[5] = '';
charArray0[6] = '?';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 260, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-32768), (-32768), false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(260, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'p', 'c', ':', '`', 'R', '', '?'}, charArray0);
assertEquals(7, charArray0.length);
char char0 = readerBasedJsonParser0.getNextChar("h5Cj<>U<e$6");
assertEquals('J', char0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(260, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'J', 'R', '3', 'y', 'C', '{', 'l'}, charArray0);
assertEquals(7, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test255() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3123);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2687, (Reader) null, objectCodec0, charsToNameCanonicalizer1, (char[]) null, (-1315), 97, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2687, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
// Undeclared exception!
// try {
readerBasedJsonParser0.getNextChar("Illegal character (");
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test256() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
Integer integer0 = new Integer(1);
assertEquals(1, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("6.");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('.' (code 46)) in numeric value: Decimal point not followed by a digit
// // at [Source: java.lang.Integer@0000000153; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test257() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(93);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = 's';
charArray0[1] = '?';
charArray0[2] = '/';
charArray0[3] = '1';
charArray0[4] = 'B';
charArray0[5] = '>';
charArray0[6] = 'C';
charArray0[7] = 'G';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, (-3121), true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'s', '?', '/', '1', 'B', '>', 'C', 'G'}, charArray0);
assertEquals(8, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'b', 'j', 'e', 'c', 't', ',', ' ', '\''}, charArray0);
assertEquals(8, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("true", string0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'t', 'r', 'u', 'e', '\'', ',', ' ', '\''}, charArray0);
assertEquals(8, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test258() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[7];
charArray0[0] = ';';
charArray0[1] = ')';
charArray0[2] = ';';
charArray0[3] = ')';
charArray0[4] = ')';
charArray0[5] = ')';
charArray0[6] = ';';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1102, 33, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {';', ')', ';', ')', ')', ')', ';'}, charArray0);
assertEquals(7, charArray0.length);
SerializedString serializedString0 = new SerializedString("false");
assertNotNull(serializedString0);
assertEquals(5, serializedString0.charLength());
assertEquals("false", serializedString0.getValue());
assertEquals("false", serializedString0.toString());
SerializedString serializedString1 = new SerializedString("R|'=um+*b2sh ");
assertFalse(serializedString1.equals((Object)serializedString0));
assertNotNull(serializedString1);
assertEquals(13, serializedString1.charLength());
assertEquals("R|'=um+*b2sh ", serializedString1.toString());
assertEquals("R|'=um+*b2sh ", serializedString1.getValue());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString1);
assertFalse(boolean0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(serializedString1.equals((Object)serializedString0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(13, serializedString1.charLength());
assertEquals("R|'=um+*b2sh ", serializedString1.toString());
assertEquals("R|'=um+*b2sh ", serializedString1.getValue());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(34L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(35, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'f', 'a', 'l', 's', 'e', ')', ';'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(serializedString1, serializedString0);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-inputNo digit following minus sign
// // at [Source: com.fasterxml.jackson.core.io.IOContext@0000000154; line: 1, column: 49]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test259() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'QWnqca4=");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[9];
charArray0[0] = 'T';
charArray0[1] = ':';
charArray0[2] = '6';
charArray0[3] = '$';
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec1).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec1).toString();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, 48, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'T', ':', '6', '$', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(9, charArray0.length);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(treeNode0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'T', ':', '6', '$', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(9, charArray0.length);
assertSame(iOContext0, iOContext1);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(350);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 35, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3571, 3571, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(35, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertArrayEquals(new char[] {'T', ':', '6', '$', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(9, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: java.lang.String@0000000155; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test260() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, fileSystemHandling0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("Q}>Pj");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
charArray0[0] = 'A';
charArray0[1] = 'A';
charArray0[2] = '\'';
charArray0[3] = '/';
charArray0[4] = '>';
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'Q', '}', '>', 'P', 'j'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(97);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Object object0 = readerBasedJsonParser0.getObjectId();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(object0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 125, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(125, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
long long0 = readerBasedJsonParser1.nextLongValue(1);
assertEquals(1L, long0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(125, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertTrue(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(iOContext1, iOContext0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test261() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("\"St ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader2 = new StringReader("]&");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
char[] charArray0 = iOContext1.allocNameCopyBuffer((-6618));
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(200, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader2);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer4);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000156; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test262() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("1F");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 130, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer4);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(130, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('F' (code 70)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000157; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test263() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("\"(@_thbofb^\"FC-y<q/");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-2464L));
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader1 = new StringReader("\"(@_thbofb^\"FC-y<q/");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = stringReader0.read();
assertEquals(34, int0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
char[] charArray0 = iOContext2.allocNameCopyBuffer(34);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(200, charArray0.length);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._handleOddName(52);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('4' (code 52)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000158; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test264() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 9, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1427, (-4), false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(9, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read -4
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test265() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 7, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"'}, charArray0);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._skipString();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"'}, charArray0);
assertEquals(4, charArray0.length);
readerBasedJsonParser0._closeInput();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-1), readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', '\"', '\"', '\"'}, charArray0);
assertEquals(4, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 101, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(101, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
ObjectCodec objectCodec0 = null;
int int0 = 102;
String string0 = "q^!;Y\\7[m^<f|.jzOA";
StringReader stringReader1 = new StringReader("q^!;Y\u0007[m^<f|.jzOA");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int1 = 2;
TypeReference<Object> typeReference0 = (TypeReference<Object>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
// Undeclared exception!
// try {
readerBasedJsonParser1.readValueAs((TypeReference<?>) typeReference0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // No ObjectCodec defined for parser, needed for deserialization
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test266() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
String string0 = "0Ur@<ht#UWk<g";
StringReader stringReader1 = new StringReader("0Ur@<ht#UWk<g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'j';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(object0.equals((Object)stringReader0));
assertNotNull(object0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(object0, stringReader1);
assertNotSame(object0, stringReader0);
Object object1 = readerBasedJsonParser0.getEmbeddedObject();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(object1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader1, objectCodec1, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000159; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test267() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("M-D6KKc$}BnE\u0004eq");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
long long0 = stringReader0.skip(0);
assertEquals(0L, long0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[9];
charArray0[0] = 'V';
charArray0[1] = '`';
charArray0[2] = 'V';
charArray0[3] = 'c';
charArray0[4] = 'V';
charArray0[5] = 'V';
charArray0[6] = 'V';
charArray0[7] = 'c';
charArray0[8] = 'c';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 994, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 126, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(994, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertArrayEquals(new char[] {'V', '`', 'V', 'c', 'V', 'V', 'V', 'c', 'c'}, charArray0);
assertEquals(9, charArray0.length);
// try {
readerBasedJsonParser0.getBinaryValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000160; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test268() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("Ag 4NQy7T");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
char[] charArray0 = new char[7];
charArray0[0] = 'p';
charArray0[1] = 'M';
charArray0[2] = 'B';
charArray0[3] = '<';
charArray0[4] = 'p';
charArray0[5] = 'z';
charArray0[6] = 'O';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 178, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, 46, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(178, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertArrayEquals(new char[] {'p', 'M', 'B', '<', 'p', 'z', 'O'}, charArray0);
assertEquals(7, charArray0.length);
TypeReference<Object> typeReference0 = (TypeReference<Object>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Integer integer0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(integer0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(178, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertArrayEquals(new char[] {'p', 'M', 'B', '<', 'p', 'z', 'O'}, charArray0);
assertEquals(7, charArray0.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 1, stringReader1, objectCodec1, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_FLOAT;
String string0 = readerBasedJsonParser1._getText2(jsonToken0);
assertEquals("", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(string0);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(iOContext1, iOContext2);
assertNotSame(stringReader1, stringReader0);
assertSame(iOContext2, iOContext1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
}
@Test(timeout = 4000)
public void test269() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-570), stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(jsonToken0.isNumeric());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isStructEnd());
assertEquals(8, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals("-Infinity", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-570), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
}
@Test(timeout = 4000)
public void test270() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader1 = new StringReader("\"St ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader2 = new StringReader("]&");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
StringReader stringReader3 = new StringReader("D;xh Zg");
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertNotNull(stringReader3);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader1, objectCodec0, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader3));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
int int0 = readerBasedJsonParser0.nextIntValue(3);
assertEquals(3, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader3));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader3);
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, stringReader2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertSame(iOContext1, iOContext0);
// try {
readerBasedJsonParser0.getTextCharacters();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000161; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test271() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("\"");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(1);
assertEquals(1L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = stringReader0.read();
assertEquals((-1), int0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("\"");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) null);
assertFalse(boolean0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
byte[] byteArray0 = iOContext1.allocBase64Buffer();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArray0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(2000, byteArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
// try {
readerBasedJsonParser0.getTextCharacters();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000162; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test272() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("IDLBeJXanh X");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
charArray0[0] = '6';
charArray0[1] = '[';
charArray0[2] = 'f';
charArray0[3] = '\'';
charArray0[4] = '5';
stringReader0.close();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 110, 3, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'6', '[', 'f', '\'', '5'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test273() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("xY|wFG`X{h-&Qgtht{");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-INF");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 612, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(612, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '-INF': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.io.IOContext@0000000163; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test274() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
int int0 = (-282);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec0).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-282), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals((-282), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(treeNode0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals((-282), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNotSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
IOContext iOContext3 = new IOContext(bufferRecycler0, iOContext1, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 78, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(78, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
char[] charArray0 = iOContext1.allocNameCopyBuffer(3);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(200, charArray0.length);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext1, iOContext3);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '-INF': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000164; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test275() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-INfinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 93, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(93, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '-INfinity': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000165; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test276() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocConcatBuffer();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0._parseName();
assertEquals(":", string1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
// Undeclared exception!
// try {
readerBasedJsonParser0.getValueAsString("s[uMhU");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 4
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test277() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
iOContext0.setEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("x)u]v:Kt /");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 110, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 1, 110, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(110, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// Undeclared exception!
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test278() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader(">Isy\"C<!y50{Xy,A");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'V';
charArray0[1] = 'c';
charArray0[2] = '`';
long long0 = stringReader0.skip(0L);
assertEquals(0L, long0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-489), 0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'V', 'c', '`'}, charArray0);
assertEquals(3, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals((-488), jsonLocation0.getColumnNr());
assertEquals((-489L), jsonLocation0.getCharOffset());
assertArrayEquals(new char[] {'V', 'c', '`'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -489
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test279() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
boolean boolean0 = true;
IOContext iOContext1 = new IOContext((BufferRecycler) null, charsToNameCanonicalizer0, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[7];
charArray0[0] = ';';
charArray0[1] = ':';
charArray0[2] = ';';
charArray0[3] = ';';
charArray0[4] = ')';
charArray0[5] = ')';
charArray0[6] = ';';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2985), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, 2, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-2985), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {';', ':', ';', ';', ')', ')', ';'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000166; line: 1, column: 21]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test280() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4000, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(4000, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000167; line: 1, column: 33]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test281() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(57);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3566), stringReader2, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-3566), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
JsonToken jsonToken0 = JsonToken.END_ARRAY;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("]", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-3566), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(stringReader2, stringReader1);
assertNotSame(stringReader2, stringReader0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'Q';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2942, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 262144, 1, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(2942, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'Q'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser1.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000168; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test282() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
String string0 = "9+`a";
StringReader stringReader0 = new StringReader("9+`a");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 2, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'\u0000'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('+' (code 43)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000169; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test283() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("!4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
int int0 = (-2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("!4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('!' (code 33)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000170; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test284() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("<>rO%6YC%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 57, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "<>rO%6YC%");
assertFalse(boolean0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(192, "Current token (");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000171; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test285() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("$Cj1{-YAv#)v1e");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 117, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(117, readerBasedJsonParser0.getFeatureMask());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(39, "!4)O24;p]f4ocT<<");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000172; line: 1, column: 29]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test286() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
charArray0[1] = 'C';
int int0 = 5027;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 5027, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 621, (-2), false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(5027, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'\u0000', 'C'}, charArray0);
assertEquals(2, charArray0.length);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
String string0 = readerBasedJsonParser0._parseAposName();
assertEquals("expected a valid value (number, String, array, object, ", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(string0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(5027, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000173; line: 1, column: 81]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test287() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec0).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(treeNode0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 50, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(50, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
int int0 = 10;
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext2, 1, stringReader0, objectCodec2, charsToNameCanonicalizer0, (char[]) null, 93, 10, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(1, readerBasedJsonParser2.getFeatureMask());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
// try {
readerBasedJsonParser1._isNextTokenNameMaybe(39, "expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('t' (code 116)): was expecting a colon to separate field name and value
// // at [Source: UNKNOWN; line: 1, column: 58]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test288() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 16, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 0, (-1035), false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// Undeclared exception!
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test289() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("t");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
JsonToken jsonToken0 = JsonToken.VALUE_STRING;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
char char0 = 'Q';
char[] charArray0 = new char[1];
charArray0[0] = '>';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-683), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1158, 0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals((-683), readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertArrayEquals(new char[] {'>'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 't': was expecting 'null', 'true', 'false' or NaN
// // at [Source: java.lang.String@0000000174; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test290() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
iOContext0.setEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("expected a valid value (number, String, array, object, ", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isBoolean());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
long long0 = readerBasedJsonParser0.nextLongValue(3);
assertEquals(3L, long0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test291() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader1 = new StringReader("INT");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = '>';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1, 1, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test292() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("f5P={");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
int int0 = 200;
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec0).toString();
char[] charArray0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 200, stringReader1, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, 1, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
TypeReference<String> typeReference0 = (TypeReference<String>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Object object0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(object0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(200, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
IOContext iOContext2 = new IOContext(bufferRecycler0, "", true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 200, stringReader1, objectCodec1, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(200, readerBasedJsonParser1.getFeatureMask());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
// Undeclared exception!
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test293() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = null;
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
boolean boolean0 = false;
IOContext iOContext1 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("Jm-@Hqf");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 32767, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(32767, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
char[] charArray0 = iOContext1.allocNameCopyBuffer(3);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(charArray0);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(200, charArray0.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertNotSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 32767, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-672), 55, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(32767, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(200, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -672
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test294() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
int int0 = stringReader0.read();
assertEquals(41, int0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3096), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
char[] charArray0 = new char[6];
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
charArray0[0] = 'h';
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 127)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000175; line: 2, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test295() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean2 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.setEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = ']';
charArray0[1] = ']';
charArray0[2] = '*';
charArray0[3] = '*';
charArray0[4] = '(';
charArray0[5] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 48, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertArrayEquals(new char[] {']', ']', '*', '*', '(', ']'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000176; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test296() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("]#p$^[W/jZ");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 11, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(11, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000177; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test297() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("true");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
JsonToken jsonToken0 = JsonToken.FIELD_NAME;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
char[] charArray0 = new char[8];
charArray0[1] = '{';
charArray0[3] = '>';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, 3, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertArrayEquals(new char[] {'\u0000', '{', '\u0000', '>', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(8, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext0, (-1502), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser2);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertFalse(readerBasedJsonParser2.isClosed());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals((-1502), readerBasedJsonParser2.getFeatureMask());
String string1 = readerBasedJsonParser2.nextFieldName();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertNull(string1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser2.getCurrentToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(1L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertTrue(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertEquals(2, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals((-1502), readerBasedJsonParser2.getFeatureMask());
assertEquals(9, readerBasedJsonParser2.getCurrentTokenId());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser1);
assertNotSame(readerBasedJsonParser2, readerBasedJsonParser0);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('t' (code 116)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.io.IOContext@0000000178; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test298() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[1];
int int0 = stringReader0.read(charArray0);
assertEquals(1, int0);
assertArrayEquals(new char[] {'-'}, charArray0);
assertEquals(1, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 2, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'-'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber(1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '+Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000179; line: 1, column: 12]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test299() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.setEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[2];
charArray0[0] = '(';
charArray0[1] = '(';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2093), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 117, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-2093), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'(', '('}, charArray0);
assertEquals(2, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
// try {
readerBasedJsonParser1.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '-Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000180; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test300() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = stringReader1.read();
assertEquals(45, int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '-Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000181; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test301() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[0];
int int0 = stringReader0.read(charArray0);
assertEquals(0, int0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('X' (code 88)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000182; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test302() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
charArray0[1] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\u0000', 'C'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test303() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "4B)", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("false");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader2 = new StringReader("xmP{#0xS (pe");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
StringReader stringReader3 = new StringReader("false");
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(stringReader3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader3, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
int int0 = readerBasedJsonParser0.nextIntValue(2);
assertEquals(2, int0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader3, stringReader0);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader1);
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'f', 'a', 'l', 's', 'e'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader3, stringReader0);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader1);
String string0 = readerBasedJsonParser0.getValueAsString("SnnDX[");
assertEquals("false", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader3, stringReader0);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader1);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNull(boolean0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader3, stringReader0);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader1);
}
@Test(timeout = 4000)
public void test304() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
iOContext0.setEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertNull(jsonToken0.asString());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructEnd());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertArrayEquals(new char[] {'t', 'r', 'u', 'e'}, charArray1);
assertEquals(2, charArray0.length);
assertEquals(4, charArray1.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charArray0, charArray1);
assertNotSame(charArray1, charArray0);
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (''' (code 39)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000183; line: 1, column: -3059]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test305() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Object object1 = readerBasedJsonParser0.getInputSource();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(object1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object1);
assertSame(object1, stringReader0);
Object object2 = readerBasedJsonParser0.getEmbeddedObject();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(byteArray0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(8000, byteArray0.length);
assertNotSame(iOContext1, iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
char[] charArray0 = new char[2];
charArray0[0] = 'Y';
charArray0[1] = 'v';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-304), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 3, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals((-304), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertArrayEquals(new char[] {'Y', 'v'}, charArray0);
assertEquals(2, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1._parseAposName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 2
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test306() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[0];
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 43, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 43, 200, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(43, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
TypeReference<Object> typeReference0 = (TypeReference<Object>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Object object0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(object0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(43, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 200, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(200, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
// Undeclared exception!
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 43
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test307() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
Integer integer0 = new Integer(3);
assertEquals(3, (int)integer0);
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocTokenBuffer((-799));
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
StringReader stringReader1 = new StringReader("0123456789ABCDEF");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-148), (-148), true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(4000, charArray0.length);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Invalid numeric value: Leading zeroes not allowed
// // at [Source: java.lang.Integer@0000000184; line: 1, column: -146]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test308() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("'0%D<to[/t1zWT)!P%A");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'N';
int int0 = stringReader0.read(charArray0);
assertEquals(1, int0);
assertArrayEquals(new char[] {'\''}, charArray0);
assertEquals(1, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 92, 1, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\''}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('%' (code 37)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000185; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test309() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader1 = new StringReader("0Ur@<ht#UWk<g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[1];
charArray0[0] = 'j';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, (-2476), (-2261), true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'j'}, charArray0);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1886);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 43, stringReader1, objectCodec1, charsToNameCanonicalizer1, charArray0, 729, 3, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(43, readerBasedJsonParser1.getFeatureMask());
assertArrayEquals(new char[] {'j'}, charArray0);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("$v[]OA");
assertNotNull(serializedString0);
assertEquals("$v[]OA", serializedString0.getValue());
assertEquals("$v[]OA", serializedString0.toString());
assertEquals(6, serializedString0.charLength());
// try {
readerBasedJsonParser1.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000186; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test310() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
StringReader stringReader0 = new StringReader("+rbIEj6j$$\"0#RMTPTO");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 13, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(13, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(13, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
readerBasedJsonParser0._finishString();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(13, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
}
@Test(timeout = 4000)
public void test311() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("[C");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader2 = new StringReader("[C");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
char[] charArray0 = iOContext0.allocNameCopyBuffer(3);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(200, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 57, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(200, charArray0.length);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000187; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test312() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("j80~xZ$ZPB");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized character escape 'j' (code 106)
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000188; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test313() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, "?V%@dGb*o;~8T7uRVL", false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("?V%@dGb*o;~8T7uRVL");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[6];
charArray0[0] = 'T';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
charArray0[4] = '#';
charArray0[5] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 46, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'T', '\"', '\"', '\"', '#', '#'}, charArray0);
assertEquals(6, charArray0.length);
readerBasedJsonParser0._finishString();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'T', '\"', '\"', '\"', '#', '#'}, charArray0);
assertEquals(6, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test314() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("true");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3038, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
char[] charArray0 = iOContext0.allocNameCopyBuffer(1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
assertNotSame(iOContext0, iOContext1);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_TRUE, jsonToken0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(9, jsonToken0.id());
assertTrue(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals("true", jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
StringReader stringReader2 = new StringReader("true");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
IOContext iOContext2 = new IOContext(bufferRecycler0, iOContext0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
char[] charArray1 = iOContext2.allocConcatBuffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(4000, charArray1.length);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(charArray1, charArray0);
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, true, true);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-688), stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 2542, 255, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(readerBasedJsonParser1);
assertEquals((-688), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(200, charArray0.length);
String string0 = readerBasedJsonParser1.getValueAsString("false");
assertEquals("false", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charArray0.equals((Object)charArray1));
assertNotNull(string0);
assertEquals((-688), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(200, charArray0.length);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(stringReader0, stringReader2);
assertNotSame(charArray0, charArray1);
Boolean boolean2 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(boolean2);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader2);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser1._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000189; line: 1, column: 266]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test315() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("e[N1=vzFrJ\"?t");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader1 = new StringReader("[mJiow(");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[1];
charArray0[0] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 56, 42, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"'}, charArray0);
assertEquals(1, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonToken.START_ARRAY, readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(43L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isExpectedStartArrayToken());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(44, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'['}, charArray0);
assertEquals(1, charArray0.length);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._handleOddValue(41);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000190; line: 1, column: 44]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test316() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1543));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString(": was expecting closing quote for a string value");
assertNotNull(serializedString0);
assertEquals(48, serializedString0.charLength());
assertEquals(": was expecting closing quote for a string value", serializedString0.getValue());
assertEquals(": was expecting closing quote for a string value", serializedString0.toString());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
char[] charArray0 = new char[4];
charArray0[0] = '}';
charArray0[1] = 'f';
charArray0[2] = '?';
charArray0[3] = 'K';
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer0.makeChild(439);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer4);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.size());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1380, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-592), 4, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1380, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertArrayEquals(new char[] {'}', 'f', '?', 'K'}, charArray0);
assertEquals(4, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.getNextChar(": was expecting closing quote for a string value");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -592
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test317() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
charArray0[1] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\u0000', 'C'}, charArray0);
assertEquals(2, charArray0.length);
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isStructStart());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isScalarValue());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(charArray1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
long long0 = readerBasedJsonParser0.nextLongValue(3);
assertEquals(3L, long0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(jsonLocation0);
assertEquals((-3064), jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-3065L), jsonLocation0.getCharOffset());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char char0 = readerBasedJsonParser0.getNextChar("mi>lT7;p9");
assertEquals('\'', char0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringWriter stringWriter0 = new StringWriter(76);
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
StringWriter stringWriter1 = stringWriter0.append((CharSequence) "mi>lT7;p9");
assertNotNull(stringWriter1);
assertEquals("mi>lT7;p9", stringWriter0.toString());
assertEquals("mi>lT7;p9", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter1);
assertEquals(1, int0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals("mi>lT7;p9,", stringWriter0.toString());
assertEquals("mi>lT7;p9,", stringWriter1.toString());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals((-3064L), readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-3064), readerBasedJsonParser0.getTokenColumnNr());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\'', ','}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(stringWriter0, stringWriter1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(stringWriter1, stringWriter0);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test318() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[0];
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 829, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.getNextChar("': was expecting ");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 33
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test319() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
stringReader0.reset();
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("x)u]v:mt /");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = '?';
charArray0[1] = '?';
charArray0[2] = '+';
charArray0[3] = 'o';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 3, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'?', '?', '+', 'o'}, charArray0);
assertEquals(4, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
StringWriter stringWriter1 = new StringWriter();
assertFalse(stringWriter1.equals((Object)stringWriter0));
assertNotNull(stringWriter1);
assertEquals("", stringWriter1.toString());
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
assertEquals(2, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringWriter0.equals((Object)stringWriter1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertEquals("?+", stringWriter0.toString());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'?', '?', '+', 'o'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringWriter0, stringWriter1);
assertNotSame(stringReader0, stringReader1);
int int1 = readerBasedJsonParser0.getTextLength();
assertEquals(0, int1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(int1 == int0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'?', '?', '+', 'o'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(stringReader0, stringReader1);
}
@Test(timeout = 4000)
public void test320() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "n]f{C&h.$25@;o[YL20", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("n]f{C&h.$25@;o[YL20");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2883), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-2883), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
char[] charArray0 = iOContext0.allocNameCopyBuffer(91);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(200, charArray0.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// // at [Source: java.lang.String@0000000191; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test321() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("Null String illegal for SerializedString");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'K';
charArray0[1] = 'K';
charArray0[2] = 'K';
charArray0[3] = 'K';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 16, 2, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'K', 'K', 'K', 'K'}, charArray0);
assertEquals(4, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 2553, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'K', 'K', 'K', 'K'}, charArray0);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("K=vi<t&~1,A[");
assertNotNull(serializedString0);
assertEquals("K=vi<t&~1,A[", serializedString0.toString());
assertEquals(12, serializedString0.charLength());
assertEquals("K=vi<t&~1,A[", serializedString0.getValue());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'Null': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000192; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test322() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = "Null String illegal for SerializedString";
StringReader stringReader0 = new StringReader("Null String illegal for SerializedString");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 92, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(92, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'Null': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000193; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test323() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-Ininity");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = null;
int int0 = 2385;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 3, 33, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// Undeclared exception!
// try {
readerBasedJsonParser0._skipCR();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test324() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("L#aV|xlTY^aV");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(2316);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[5];
charArray0[0] = 'c';
charArray0[1] = ']';
charArray0[2] = '9';
charArray0[3] = 'd';
charArray0[4] = 'q';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 46, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-31), 2479, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'c', ']', '9', 'd', 'q'}, charArray0);
assertEquals(5, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -31
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test325() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
String string0 = "0Unr@<ht#UWk<g";
ObjectCodec objectCodec0 = null;
StringReader stringReader0 = new StringReader("0Unr@<ht#UWk<g");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
SerializableString serializableString0 = null;
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('U' (code 85)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000194; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test326() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("6RZ0}");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = '^';
charArray0[1] = 'U';
charArray0[2] = 'D';
int int0 = stringReader0.read(charArray0);
assertEquals(3, int0);
assertArrayEquals(new char[] {'6', 'R', 'Z'}, charArray0);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('}' (code 125)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000195; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test327() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(0L);
assertEquals(0L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = stringReader0.read();
assertEquals(42, int0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(iOContext0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 125, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(125, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('}' (code 125)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000196; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test328() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("[z v~A)4$CP'h#G");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[8];
charArray0[0] = 'n';
charArray0[1] = 'w';
charArray0[2] = 'l';
charArray0[3] = ']';
charArray0[4] = 'i';
charArray0[5] = '\\';
charArray0[6] = '7';
charArray0[7] = 'D';
int int0 = stringReader0.read(charArray0);
assertEquals(8, int0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertArrayEquals(new char[] {'4', ')', 'O', '2', '4', ';', 'p', ']'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(stringReader0, stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
// try {
readerBasedJsonParser0.nextLongValue(0L);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'f4ocT': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000197; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test329() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "4B)", true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
StringReader stringReader1 = new StringReader("false");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = "x\\mP{#0xS (pe";
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader2 = new StringReader("xmP{#0xS (pe");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
StringReader stringReader3 = new StringReader("false");
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertNotNull(stringReader3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader3, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
int int0 = readerBasedJsonParser0.nextIntValue(2);
assertEquals(2, int0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader3, stringReader1);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader0);
long long0 = readerBasedJsonParser0.nextLongValue(2);
assertEquals(2L, long0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(stringReader3, stringReader1);
assertNotSame(stringReader3, stringReader2);
assertNotSame(stringReader3, stringReader0);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000198; line: 1, column: 21]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test330() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
TextBuffer textBuffer0 = iOContext1.constructTextBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(textBuffer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
StringReader stringReader1 = new StringReader("Leading zeroes not allowed");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
StringReader stringReader2 = new StringReader("Leading zeroes not allowed");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
IOContext iOContext2 = new IOContext(bufferRecycler0, jsonEncoding0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
JsonEncoding jsonEncoding2 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(iOContext3);
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(jsonEncoding0, jsonEncoding2);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertSame(jsonEncoding2, jsonEncoding0);
long long0 = readerBasedJsonParser0._nameStartOffset;
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader3 = new StringReader("string value");
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertNotNull(stringReader3);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-1646), stringReader3, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser1);
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals((-1646), readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext3, 46, stringReader3, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1095), (-1646), true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(stringReader3.equals((Object)stringReader2));
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertNotNull(readerBasedJsonParser2);
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertFalse(readerBasedJsonParser2.isClosed());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser2.getCurrentName());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(46, readerBasedJsonParser2.getFeatureMask());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser2._isNextTokenNameMaybe(116, "");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('v' (code 118)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.JsonEncoding@0000000034; line: 1, column: -1637]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test331() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
int int0 = stringReader0.read();
assertEquals(41, int0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3096), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 3, 1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(53, "");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in FIELD_NAME
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000199; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test332() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
String string0 = "'";
StringReader stringReader0 = new StringReader("'");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: UNKNOWN; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test333() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[2];
charArray0[0] = ':';
charArray0[1] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 2, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {':', '\"'}, charArray0);
assertEquals(2, charArray0.length);
String string0 = readerBasedJsonParser0._parseName();
assertEquals("", string0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {':', '\"'}, charArray0);
assertEquals(2, charArray0.length);
String string1 = readerBasedJsonParser0.getValueAsString("SA4KolMvB7K]Z4");
assertEquals("SA4KolMvB7K]Z4", string1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {':', '\"'}, charArray0);
assertEquals(2, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-2090), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals((-2090), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
Boolean boolean0 = readerBasedJsonParser1.nextBooleanValue();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(boolean0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertTrue(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals((-2090), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
}
@Test(timeout = 4000)
public void test334() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray1 = iOContext0.allocConcatBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray1.length);
assertNotSame(charArray1, charArray0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0._parseName();
assertEquals(":", string1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(charsToNameCanonicalizer0.maybeDirty());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charArray0, charArray1);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._handleInvalidNumberStart(57, true);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('9' (code 57)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000200; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test335() throws Throwable {
char[] charArray0 = new char[6];
charArray0[0] = '~';
charArray0[1] = '9';
charArray0[2] = 'H';
charArray0[3] = 'n';
charArray0[4] = 'O';
charArray0[5] = 'e';
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((char[]) null).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((TreeNode) null).when(objectCodec0).readTree(any(com.fasterxml.jackson.core.JsonParser.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 903, (Reader) null, objectCodec0, charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(903, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
Object object0 = readerBasedJsonParser0.getTypeId();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(903, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
TextBuffer textBuffer0 = iOContext2.constructTextBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(textBuffer0);
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
TreeNode treeNode0 = readerBasedJsonParser0.readValueAsTree();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(treeNode0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(903, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
IOContext iOContext3 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn(charArray0).when(iOContext3).allocTokenBuffer();
doReturn(textBuffer0).when(iOContext3).constructTextBuffer();
doReturn((Object) null).when(iOContext3).getSourceReference();
doReturn(false).when(iOContext3).isResourceManaged();
StringReader stringReader0 = new StringReader("#*=]TWTQuH~N-/!E");
assertNotNull(stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
int int0 = stringReader0.read();
assertEquals(35, int0);
StringReader stringReader1 = new StringReader("#*=]TWTQuH~N-/!E");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 48, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext3));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(48, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertArrayEquals(new char[] {'~', '9', 'H', 'n', 'O', 'e'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser1._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: UNKNOWN; line: 1, column: 25]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test336() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("2.2250738585072012e-308");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
stringReader0.reset();
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('.' (code 46)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000201; line: 2, column: 26]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test337() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = ')';
charArray0[1] = ')';
charArray0[2] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1180, 0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {')', ')', ')'}, charArray0);
assertEquals(3, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000202; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test338() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("_lH$?B:");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
SerializedString serializedString0 = new SerializedString("com.fasterxml.jackson.core.JsonParseException");
assertNotNull(serializedString0);
assertEquals(45, serializedString0.charLength());
assertEquals("com.fasterxml.jackson.core.JsonParseException", serializedString0.toString());
assertEquals("com.fasterxml.jackson.core.JsonParseException", serializedString0.getValue());
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
char[] charArray0 = new char[5];
charArray0[3] = '/';
charArray0[2] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 6, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 33, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\u0000', '\u0000', '/', '/', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\u0000', '\u0000', '/', '/', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: java.io.StringReader@0000000203; line: 2, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test339() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
charsToNameCanonicalizer2.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[6];
charArray0[0] = '/';
charArray0[1] = '/';
charArray0[2] = '/';
charArray0[3] = '/';
charArray0[4] = '/';
charArray0[5] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1858), stringReader0, objectCodec0, charsToNameCanonicalizer2, charArray0, 3, 17, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-1858), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertArrayEquals(new char[] {'/', '/', '/', '/', '/', '/'}, charArray0);
assertEquals(6, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 6
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test340() throws Throwable {
StringReader stringReader0 = new StringReader("F");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "'QWnqca4=", false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[7];
charArray0[0] = '\'';
charArray0[1] = 'P';
charArray0[2] = 's';
charArray0[3] = '';
charArray0[4] = 'n';
charArray0[5] = '*';
charArray0[6] = ']';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 51, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1858), 63, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(51, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'\'', 'P', 's', '', 'n', '*', ']'}, charArray0);
assertEquals(7, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1858
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test341() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[0];
int int0 = stringReader0.read(charArray0);
assertEquals(0, int0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '/';
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 17, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(17, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
String string0 = readerBasedJsonParser0.getValueAsString("%'G8d6p)O");
assertEquals("%'G8d6p)O", string0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(string0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(17, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('X' (code 88)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000204; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test342() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
String string0 = "x)u]v:mt /";
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("x)u]v:mt /");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2502, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2502, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser0.nextLongValue(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test343() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader0 = new StringReader("#%3[tabwY^k:>^@Yj6,");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
StringReader stringReader1 = new StringReader("was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextIntValue(1035);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('#' (code 35)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000205; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test344() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("3%g|!RR#@FeU*J\"t@X");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-931), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-931), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('%' (code 37)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000206; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test345() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("e[N1=vzFrJ\"?t");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
iOContext0.setEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1554, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 1, 1387, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1554, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
StringWriter stringWriter0 = new StringWriter();
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
StringWriter stringWriter1 = new StringWriter();
assertFalse(stringWriter1.equals((Object)stringWriter0));
assertNotNull(stringWriter1);
assertEquals("", stringWriter1.toString());
// Undeclared exception!
// try {
readerBasedJsonParser0.releaseBuffered((Writer) stringWriter1);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.StringWriter", e);
// }
}
@Test(timeout = 4000)
public void test346() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn("'f3?palvy").when(objectCodec0).toString();
char[] charArray0 = new char[6];
charArray0[0] = '\t';
charArray0[1] = '\t';
charArray0[3] = '\t';
charArray0[1] = '#';
charArray0[5] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 46, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
ObjectCodec objectCodec1 = readerBasedJsonParser0.getCodec();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(objectCodec1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
assertSame(objectCodec1, objectCodec0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 93, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 1, 93, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(93, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'\t', '#', '\u0000', '\t', '\u0000', '#'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000207; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test347() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("#*=]TWTQuH~N-/!E");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(iOContext0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
Object object0 = readerBasedJsonParser0.getObjectId();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
IOContext iOContext1 = new IOContext(bufferRecycler0, readerBasedJsonParser0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
IOContext iOContext3 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(iOContext3);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[4];
charArray0[0] = 'q';
charArray0[1] = 'O';
charArray0[2] = 'O';
charArray0[3] = '*';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 0, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, (-624), 1969, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser1);
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertArrayEquals(new char[] {'q', 'O', 'O', '*'}, charArray0);
assertEquals(4, charArray0.length);
ObjectCodec objectCodec2 = readerBasedJsonParser0.getCodec();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(objectCodec2.equals((Object)objectCodec1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNotNull(objectCodec2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(objectCodec2, objectCodec0);
assertNotSame(objectCodec2, objectCodec1);
assertSame(iOContext0, iOContext3);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser0.nextLongValue(1L);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('#' (code 35)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000208; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test348() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'f3?palvy");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("'f3?palvy");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
char[] charArray0 = new char[3];
charArray0[0] = '\t';
charArray0[1] = '\t';
charArray0[2] = '\t';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 5, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 2, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(5, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\t', '\t', '\t'}, charArray0);
assertEquals(3, charArray0.length);
Object object0 = readerBasedJsonParser0.getTypeId();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(5, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\t', '\t', '\t'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(stringReader0, stringReader1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (''' (code 39)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000209; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test349() throws Throwable {
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((char[]) null).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("#*=]TWTQuH~N-/!E");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1131, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1131, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
Object object0 = readerBasedJsonParser0.getObjectId();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1131, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
IOContext iOContext1 = new IOContext((BufferRecycler) null, (Object) null, false);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec1).toString();
char[] charArray0 = new char[3];
charArray0[0] = '*';
charArray0[1] = 'I';
charArray0[2] = 'O';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 14, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 1131, 1131, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(14, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertArrayEquals(new char[] {'*', 'I', 'O'}, charArray0);
assertEquals(3, charArray0.length);
ObjectCodec objectCodec2 = readerBasedJsonParser1.getCodec();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(objectCodec2.equals((Object)objectCodec0));
assertNotNull(objectCodec2);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(14, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertArrayEquals(new char[] {'*', 'I', 'O'}, charArray0);
assertEquals(3, charArray0.length);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(objectCodec2, objectCodec1);
assertNotSame(objectCodec2, objectCodec0);
long long0 = readerBasedJsonParser1.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(14, readerBasedJsonParser1.getFeatureMask());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertTrue(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertArrayEquals(new char[] {'/', '!', 'E'}, charArray0);
assertEquals(3, charArray0.length);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
}
@Test(timeout = 4000)
public void test350() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("#6v?");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[3];
charArray0[0] = '2';
charArray0[1] = 'U';
charArray0[2] = '\'';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 117, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 33, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(117, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'2', 'U', '\''}, charArray0);
assertEquals(3, charArray0.length);
readerBasedJsonParser0.nextToken();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(117, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'?', '6', 'v'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(iOContext0, iOContext1);
String string0 = readerBasedJsonParser0.getValueAsString("com.fasterxml.jackson.core.JsonPointer");
assertEquals("com.fasterxml.jackson.core.JsonPointer", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(117, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'?', '6', 'v'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(iOContext0, iOContext1);
// try {
stringReader0.read(charArray0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test351() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[1];
charArray0[0] = '7';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 693, 13, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'7'}, charArray0);
assertEquals(1, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'7'}, charArray0);
assertEquals(1, charArray0.length);
}
@Test(timeout = 4000)
public void test352() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "4B)", true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
int int0 = stringReader0.read();
assertEquals(42, int0);
StringReader stringReader1 = new StringReader("string value");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[8];
charArray0[0] = 'd';
charArray0[0] = '*';
charArray0[2] = '*';
charArray0[3] = 'd';
charArray0[2] = '*';
charArray0[5] = 'd';
charArray0[6] = 'd';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 201, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(201, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000210; line: 1, column: 25]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test353() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\"', '\u0000', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\"', '\u0000', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object0.equals((Object)stringReader0));
assertNotNull(object0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\"', '\u0000', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(stringReader1, object0);
assertNotSame(stringReader1, stringReader0);
assertSame(object0, stringReader1);
assertNotSame(object0, stringReader0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000211; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test354() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("true");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
char[] charArray0 = new char[8];
readerBasedJsonParser0.setCurrentValue(charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
charArray0[0] = '6';
charArray0[1] = '{';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3052, (-2913), true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertArrayEquals(new char[] {'6', '{', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(8, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser1._handleOddValue(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 2)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.io.IOContext@0000000212; line: 1, column: 3053]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test355() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test356() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'K';
StringReader stringReader1 = new StringReader("false");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, objectCodec0, charsToNameCanonicalizer1, charArray0, 51, 0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'K'}, charArray0);
assertEquals(1, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'e'}, charArray0);
assertEquals(1, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._handleOddValue(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 2)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000213; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test357() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "expected a digit for number exponent");
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
char[] charArray0 = new char[4];
charArray0[0] = 'W';
charArray0[1] = 'h';
charArray0[2] = 'g';
charArray0[3] = '1';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-431), (-1594), false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'W', 'h', 'g', '1'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser1.nextFieldName();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals((-1593), readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertTrue(readerBasedJsonParser1.hasCurrentToken());
assertEquals((-1593L), readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(10, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'e', 'a', 'l', 's'}, charArray0);
assertEquals(4, charArray0.length);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// try {
readerBasedJsonParser0._handleOddValue(116);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test358() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
String string0 = "4)O24;p]f4ocT<<\\";
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = '|';
charArray0[1] = '|';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
charArray0[2] = '.';
charArray0[3] = 'v';
charArray0[4] = '.';
charArray0[5] = '.';
charArray0[6] = '.';
charArray0[7] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000214; line: 1, column: 33]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test359() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = '/';
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 0, 33, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'/'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test360() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
charArray0[0] = 'B';
int int0 = stringReader0.read(charArray0);
assertEquals(1, int0);
assertArrayEquals(new char[] {'9'}, charArray0);
assertEquals(1, charArray0.length);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(123);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 92, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'9'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 33
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test361() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
int int0 = 36;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 8, 54, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(116, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(4000, charArray0.length);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000215; line: 1, column: 73]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test362() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(3);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[5];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1414), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 33, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-1414), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 5
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test363() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
StringReader stringReader0 = new StringReader("+rbIEj6j$$\"0#RMTPTO");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 121, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(121, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
readerBasedJsonParser0._skipString();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(121, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000216; line: 1, column: 39]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test364() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(object0.equals((Object)stringReader0));
assertNotNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertSame(stringReader1, object0);
assertNotSame(object0, stringReader0);
assertSame(object0, stringReader1);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (':' (code 58)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000217; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test365() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, true);
assertFalse(boolean0);
iOContext0.setEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 293, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 76, (-3121), false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\u0000', '\u0000'}, charArray0);
assertEquals(2, charArray0.length);
readerBasedJsonParser0._tokenIncomplete = true;
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
JsonToken jsonToken0 = readerBasedJsonParser0._handleApos();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(293, readerBasedJsonParser0.getFeatureMask());
assertFalse(jsonToken0.isStructEnd());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertNull(jsonToken0.asString());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isStructStart());
assertTrue(jsonToken0.isScalarValue());
assertArrayEquals(new char[] {' ', '\''}, charArray0);
assertEquals(2, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000218; line: 1, column: -3038]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test366() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = stringReader0.read();
assertEquals(117, int0);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: java.io.StringReader@0000000010; line: 1, column: 0])
// // at [Source: java.io.StringReader@0000000219; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test367() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("]* #&4PC");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
SerializedString serializedString0 = new SerializedString("[K$_VJ}AHWStOck'");
assertNotNull(serializedString0);
assertEquals("[K$_VJ}AHWStOck'", serializedString0.toString());
assertEquals("[K$_VJ}AHWStOck'", serializedString0.getValue());
assertEquals(16, serializedString0.charLength());
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
char[] charArray0 = new char[7];
charArray0[0] = 'Z';
charArray0[1] = 'Z';
charArray0[2] = 'Z';
charArray0[3] = '/';
charArray0[4] = 'Z';
charArray0[5] = 'Z';
charArray0[6] = 'Z';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 4705, 2, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertArrayEquals(new char[] {'Z', 'Z', 'Z', '/', 'Z', 'Z', 'Z'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker ']': expected '}' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000220; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test368() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Object object1 = readerBasedJsonParser0.getInputSource();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(object1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object1);
assertSame(object1, stringReader0);
Object object2 = readerBasedJsonParser0.getEmbeddedObject();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
byte[] byteArray0 = iOContext1.allocReadIOBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(byteArray0);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(8000, byteArray0.length);
assertNotSame(iOContext1, iOContext0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertNotSame(iOContext1, iOContext0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
char[] charArray0 = new char[3];
charArray0[0] = 'Y';
charArray0[1] = 'v';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-304), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 3, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals((-304), readerBasedJsonParser1.getFeatureMask());
assertArrayEquals(new char[] {'Y', 'v', '\u0000'}, charArray0);
assertEquals(3, charArray0.length);
// try {
readerBasedJsonParser1._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in name
// // at [Source: UNKNOWN; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test369() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("Current token (");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
JsonEncoding jsonEncoding2 = JsonEncoding.UTF8;
iOContext0.setEncoding(jsonEncoding2);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(jsonEncoding2.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding2.equals((Object)jsonEncoding0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding2, jsonEncoding1);
assertNotSame(jsonEncoding2, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[9];
charArray0[0] = '_';
charArray0[1] = '_';
charArray0[2] = '(';
charArray0[3] = '_';
charArray0[4] = 'l';
charArray0[5] = '_';
charArray0[6] = '(';
int int0 = 116;
int int1 = 102;
boolean boolean0 = true;
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
assertTrue(boolean1 == boolean0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec1).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec1).toString();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-4427), stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, (-35), 1, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-4427), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'_', '_', '(', '_', 'l', '_', '(', '\u0000', '\u0000'}, charArray0);
assertEquals(9, charArray0.length);
TypeReference<String> typeReference0 = (TypeReference<String>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
Object object0 = readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding2));
assertNull(object0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-4427), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'_', '_', '(', '_', 'l', '_', '(', '\u0000', '\u0000'}, charArray0);
assertEquals(9, charArray0.length);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding2);
assertSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
IOContext iOContext3 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
ObjectCodec objectCodec2 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 0, stringReader0, objectCodec2, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext3.equals((Object)iOContext2));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext3.isResourceManaged());
assertNull(iOContext3.getEncoding());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
// try {
readerBasedJsonParser1._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: UNKNOWN; line: 1, column: 31]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test370() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[7];
charArray0[0] = '^';
charArray0[1] = '>';
charArray0[2] = ' ';
charArray0[3] = 'c';
charArray0[4] = '(';
charArray0[5] = 'w';
charArray0[6] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'^', '>', ' ', 'c', '(', 'w', '.'}, charArray0);
assertEquals(7, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("", 2);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test371() throws Throwable {
byte[] byteArray0 = new byte[3];
byteArray0[0] = (byte)7;
byteArray0[1] = (byte) (-86);
byteArray0[2] = (byte)78;
boolean boolean0 = FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
assertFalse(boolean0);
assertArrayEquals(new byte[] {(byte)7, (byte) (-86), (byte)78}, byteArray0);
assertEquals(3, byteArray0.length);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
boolean boolean1 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(47);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
JsonParser.Feature jsonParser_Feature0 = JsonParser.Feature.STRICT_DUPLICATE_DETECTION;
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.enable(jsonParser_Feature0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(512, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(512, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
String string0 = readerBasedJsonParser0.getValueAsString("com.fasterxml.jackson.core.util.TextBuffer");
assertEquals("com.fasterxml.jackson.core.util.TextBuffer", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(512, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
stringReader0.mark(33);
String string1 = readerBasedJsonParser0.getText();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(512, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
StringReader stringReader1 = (StringReader)readerBasedJsonParser0.getInputSource();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(stringReader1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(512, readerBasedJsonParser0.getFeatureMask());
assertSame(stringReader1, stringReader0);
assertSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(jsonLocation0);
assertEquals(0L, jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(512, readerBasedJsonParser0.getFeatureMask());
assertSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000221; line: 1, column: 85]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test372() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(248);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("' (code ");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("fh");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 50, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(50, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000222; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test373() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
boolean boolean0 = true;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[2];
charArray0[0] = '.';
charArray0[1] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 3, 3, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'.', '\"'}, charArray0);
assertEquals(2, charArray0.length);
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000223; line: 1, column: 22]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test374() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "n]f{C&h.$25@;o[YL20";
IOContext iOContext0 = new IOContext(bufferRecycler0, "n]f{C&h.$25@;o[YL20", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("n]f{C&h.$25@;o[YL20");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[7];
charArray0[0] = ':';
charArray0[1] = 'T';
charArray0[2] = 'T';
charArray0[3] = 'p';
charArray0[4] = 'T';
charArray0[5] = 'p';
charArray0[6] = 'p';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-497), stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, (-497), false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-497), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {':', 'T', 'T', 'p', 'T', 'p', 'p'}, charArray0);
assertEquals(7, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 95, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(95, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
// try {
readerBasedJsonParser1.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'n': was expecting 'null', 'true', 'false' or NaN
// // at [Source: java.lang.String@0000000224; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test375() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer4);
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
charsToNameCanonicalizer2.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer5 = charsToNameCanonicalizer3.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer5.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer5);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer5.size());
assertEquals(64, charsToNameCanonicalizer5.bucketCount());
assertFalse(charsToNameCanonicalizer5.maybeDirty());
assertEquals(0, charsToNameCanonicalizer5.collisionCount());
assertEquals(0, charsToNameCanonicalizer5.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer5.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer5);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer5, charsToNameCanonicalizer2);
CharsToNameCanonicalizer charsToNameCanonicalizer6 = charsToNameCanonicalizer1.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer5));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer6.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer6.equals((Object)charsToNameCanonicalizer4));
assertFalse(charsToNameCanonicalizer6.equals((Object)charsToNameCanonicalizer5));
assertFalse(charsToNameCanonicalizer6.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer6.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer6.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer6);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer6.hashSeed());
assertEquals(0, charsToNameCanonicalizer6.collisionCount());
assertEquals(64, charsToNameCanonicalizer6.bucketCount());
assertEquals(0, charsToNameCanonicalizer6.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer6.size());
assertFalse(charsToNameCanonicalizer6.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer5);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer6);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer6, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer6, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer6, charsToNameCanonicalizer5);
assertNotSame(charsToNameCanonicalizer6, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer6, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer6, charsToNameCanonicalizer2);
StringReader stringReader0 = new StringReader("nXq7,F?hy9/>Z");
assertNotNull(stringReader0);
char[] charArray0 = new char[7];
charArray0[0] = 'B';
charArray0[1] = 'w';
charArray0[2] = 'Y';
charArray0[3] = 'e';
charArray0[4] = '*';
charArray0[5] = '7';
charArray0[6] = 'T';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2332, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer4, charArray0, 660, 0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer5));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer6));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2332, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertArrayEquals(new char[] {'B', 'w', 'Y', 'e', '*', '7', 'T'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'nXq7': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000225; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test376() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("null");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
Boolean boolean1 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(boolean1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(11, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonToken.VALUE_NULL, readerBasedJsonParser0.getCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test377() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("e[N1=vzFrJ\"?t");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
StringReader stringReader1 = new StringReader("[mJiow(");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-1414));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
char[] charArray0 = new char[2];
charArray0[0] = '\"';
charArray0[1] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1, 3, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', '\"'}, charArray0);
assertEquals(2, charArray0.length);
String string0 = readerBasedJsonParser0.nextFieldName();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'\"', '\"'}, charArray0);
assertEquals(2, charArray0.length);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._handleOddValue((-3901));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in VALUE_STRING
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000226; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test378() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'wqTx8l6WA~Kh<1U");
assertNotNull(stringReader0);
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(102);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 2, stringReader1, objectCodec0, charsToNameCanonicalizer2);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
String string0 = readerBasedJsonParser0.getValueAsString((String) null);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(JsonEncoding.UTF32_BE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'was': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000227; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test379() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("Fdv7");
assertEquals("Fdv7", string0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(boolean0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._handleInvalidNumberStart(57, true);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('9' (code 57)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000228; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test380() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader1 = new StringReader("^c+H");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1424), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals((-1424), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-1462), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1, 1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals((-1462), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser1.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000229; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test381() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader1 = new StringReader("9XU{:<ELw");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: UNKNOWN; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test382() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 55, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 2
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test383() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, "expected a digit for number exponent", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test384() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
readerBasedJsonParser0.nextValue();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) null);
assertEquals(0, int0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0._decodeBase64((Base64Variant) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000230; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test385() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.BufferRecycler");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'l';
charArray0[1] = 'l';
charArray0[2] = 'l';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, 33, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'l', 'l', 'l'}, charArray0);
assertEquals(3, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber(500);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('l' (code 108)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000231; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test386() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("Cr");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, true);
assertFalse(boolean0);
int int0 = 8;
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 8, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-2), 3, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(4000, charArray0.length);
String string0 = readerBasedJsonParser0.getValueAsString("AZ_nw$]2JlZj7Kp[h0");
assertEquals("AZ_nw$]2JlZj7Kp[h0", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(8, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(4000, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -2
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test387() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("*0}Vox|1]");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader1 = new StringReader("\"St ");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader2 = new StringReader("]&");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader3 = new StringReader("D;xh Zg");
assertFalse(stringReader3.equals((Object)stringReader0));
assertFalse(stringReader3.equals((Object)stringReader1));
assertFalse(stringReader3.equals((Object)stringReader2));
assertNotNull(stringReader3);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
int int0 = 293;
char[] charArray0 = new char[3];
charArray0[0] = 'n';
charArray0[1] = 'C';
charArray0[2] = 'C';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1, 3777, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertArrayEquals(new char[] {'n', 'C', 'C'}, charArray0);
assertEquals(3, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 3
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test388() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
StringReader stringReader0 = new StringReader("+rbIEj6j$$\"0#RMTPTO");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, (-3370), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-3370), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
char[] charArray0 = new char[5];
charArray0[0] = 'b';
charArray0[1] = '2';
charArray0[2] = ':';
charArray0[3] = '/';
charArray0[4] = '}';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1561, 962, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertArrayEquals(new char[] {'b', '2', ':', '/', '}'}, charArray0);
assertEquals(5, charArray0.length);
readerBasedJsonParser0._finishString();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals((-3370), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser1._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in character escape sequence
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000232; line: 1, column: 2524]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test389() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
StringReader stringReader1 = new StringReader("4)O24;p]f4ocT<<");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec1, charsToNameCanonicalizer0, charArray0, 0, 1469, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(0L);
assertEquals(0L, long0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
readerBasedJsonParser0._finishString2();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test390() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-14M:`H#00AS\"");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 586, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 0, 123, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(586, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test391() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(37);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("5i)cYm]rq");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[9];
charArray0[0] = '@';
charArray0[1] = 'U';
charArray0[2] = '';
charArray0[3] = '\u0083';
charArray0[4] = '/';
charArray0[5] = 'q';
charArray0[6] = 'T';
charArray0[7] = 'K';
charArray0[8] = 'Q';
StringReader stringReader2 = new StringReader("");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNull(boolean0);
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test392() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(46);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 46, stringReader0, objectCodec0, charsToNameCanonicalizer2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
charsToNameCanonicalizer2.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
iOContext1.releaseWriteEncodingBuffer((byte[]) null);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[1];
charArray0[0] = 'x';
int int0 = stringReader0.read(charArray0);
assertEquals((-1), int0);
assertArrayEquals(new char[] {'x'}, charArray0);
assertEquals(1, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 1361, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 2, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1361, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertArrayEquals(new char[] {'x'}, charArray0);
assertEquals(1, charArray0.length);
char[] charArray1 = readerBasedJsonParser1.getTextCharacters();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(charArray1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1361, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertArrayEquals(new char[] {'x'}, charArray0);
assertEquals(1, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
String string0 = readerBasedJsonParser0.getValueAsString("");
assertEquals("", string0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNotNull(string0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
Boolean boolean0 = readerBasedJsonParser0.nextBooleanValue();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(boolean0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(46, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
}
@Test(timeout = 4000)
public void test393() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
boolean boolean1 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean1);
assertTrue(boolean1 == boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
String string0 = "'";
StringReader stringReader0 = new StringReader("'");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
iOContext0.setEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: UNKNOWN; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test394() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = new StringReader("x)u]v:mt /");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
int int0 = stringReader1.read();
assertEquals(120, int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotSame(stringReader1, stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader1, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
assertNotSame(iOContext0, iOContext1);
readerBasedJsonParser0._skipCR();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = charsToNameCanonicalizer2.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
char[] charArray0 = new char[8];
charArray0[1] = ']';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-3096), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer3, charArray0, 33, 33, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-3096), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertArrayEquals(new char[] {'\u0000', ']', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(8, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser2 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 1, (-441), false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser0));
assertFalse(readerBasedJsonParser2.equals((Object)readerBasedJsonParser1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser2);
assertFalse(readerBasedJsonParser2.canReadTypeId());
assertEquals(0, readerBasedJsonParser2.getFormatFeatures());
assertFalse(readerBasedJsonParser2.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser2.getFeatureMask());
assertNull(readerBasedJsonParser2.getLastClearedToken());
assertFalse(readerBasedJsonParser2.canReadObjectId());
assertEquals(1, readerBasedJsonParser2.getTokenColumnNr());
assertFalse(readerBasedJsonParser2.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser2.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser2.isClosed());
assertFalse(readerBasedJsonParser2.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser2.getCurrentToken());
assertEquals(0, readerBasedJsonParser2.getCurrentTokenId());
assertNull(readerBasedJsonParser2.getCurrentName());
assertFalse(readerBasedJsonParser2.hasCurrentToken());
assertFalse(readerBasedJsonParser2.hasTextCharacters());
assertEquals(1, readerBasedJsonParser2.getTokenLineNr());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertArrayEquals(new char[] {'\u0000', ']', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(8, charArray0.length);
String string0 = readerBasedJsonParser1.nextTextValue();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser2));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNull(string0);
assertNull(readerBasedJsonParser1.getCurrentToken());
assertTrue(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-3096), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertArrayEquals(new char[] {'\u0000', ']', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser2);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
}
@Test(timeout = 4000)
public void test395() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
Integer integer0 = new Integer(2);
assertEquals(2, (int)integer0);
assertFalse(integer0.equals((Object)int0));
assertNotNull(integer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(integer0.equals((Object)int0));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(integer0.equals((Object)int0));
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
byte[] byteArray0 = iOContext1.allocBase64Buffer();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(integer0.equals((Object)int0));
assertNotNull(byteArray0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertEquals(2000, byteArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 47, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(integer0.equals((Object)int0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._skipCR();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 33
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test396() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '/';
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(iOContext1, iOContext0);
}
@Test(timeout = 4000)
public void test397() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("xv>ZM?c6v");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[5];
charArray0[2] = '*';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1584, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-39), 455, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1584, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'\u0000', '\u0000', '*', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._skipCR();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -39
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test398() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2000, byteArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 59, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(59, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
long long0 = stringReader0.skip(2147483647L);
assertEquals(9L, long0);
readerBasedJsonParser0._skipCR();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(59, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0.getValueAsString();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(59, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._reportInvalidToken("84)$D6Sz$5thle", "FIELD_NAME");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '84)$D6Sz$5thle': was expecting FIELD_NAME
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000233; line: 2, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test399() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'L';
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext2 = new IOContext(bufferRecycler0, object0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(byteArray0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
readerBasedJsonParser0._skipCR();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(iOContext2, iOContext1);
assertNotSame(iOContext2, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer4 = charsToNameCanonicalizer1.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer4.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer3));
assertNotNull(charsToNameCanonicalizer4);
assertFalse(charsToNameCanonicalizer4.maybeDirty());
assertEquals(0, charsToNameCanonicalizer4.size());
assertEquals(64, charsToNameCanonicalizer4.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer4.hashSeed());
assertEquals(0, charsToNameCanonicalizer4.collisionCount());
assertEquals(0, charsToNameCanonicalizer4.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer4, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer4);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer3);
}
@Test(timeout = 4000)
public void test400() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
long long1 = stringReader0.skip(1749L);
assertEquals(2L, long1);
assertTrue(long1 == long0);
int int0 = stringReader0.read();
assertEquals((-1), int0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3096), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) null);
assertFalse(boolean0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(charArray0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
char[] charArray1 = new char[6];
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(2000, byteArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
charArray1[0] = 'h';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 91, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray1, 10, 91, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(91, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertArrayEquals(new char[] {'h', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray1);
assertEquals(6, charArray1.length);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextTextValue();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 10
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test401() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000234; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test402() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertArrayEquals(new char[] {'9', 'X', 'U', '{', ':'}, charArray0);
assertEquals(5, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '/';
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000235; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test403() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("<>rO%6YC%");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 11, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(11, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
boolean boolean0 = FileSystemHandling.appendStringToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
String string0 = "Current token (";
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(1841, "'null', 'true', 'false' or NaN");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in FIELD_NAME
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000236; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test404() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:Kt /");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
StringReader stringReader1 = new StringReader("9XU{:<ELw");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[5];
charArray0[0] = 'G';
charArray0[1] = 'n';
charArray0[2] = 'A';
charArray0[3] = '\'';
charArray0[4] = '[';
int int0 = stringReader0.read(charArray0);
assertEquals(5, int0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertArrayEquals(new char[] {'u', ']', 'v', ':', 'K'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(stringReader0, stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1200);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext1 = new IOContext(bufferRecycler0, 'u', false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 47, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0.nextLongValue((-483L));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 't': was expecting 'null', 'true', 'false' or NaN
// // at [Source: java.lang.Character@0000000237; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test405() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader1 = new StringReader("true");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3038, stringReader1, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
char[] charArray0 = iOContext0.allocNameCopyBuffer(1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(200, charArray0.length);
assertNotSame(iOContext0, iOContext1);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_TRUE, jsonToken0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(jsonToken0.isNumeric());
assertTrue(jsonToken0.isBoolean());
assertTrue(jsonToken0.isScalarValue());
assertFalse(jsonToken0.isStructStart());
assertEquals(9, jsonToken0.id());
assertEquals("true", jsonToken0.asString());
assertFalse(jsonToken0.isStructEnd());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
String string0 = readerBasedJsonParser0.getText();
assertEquals("true", string0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(9, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(JsonToken.VALUE_TRUE, readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0.nextFieldName();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(string1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(3038, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader1, stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 5364, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 1874, 488, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(5364, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(200, charArray0.length);
int int0 = 32767;
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(3038, " entries");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('\u0BDE' (code 3038 / 0xbde)): was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000238; line: 1, column: 13]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test406() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(93);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[25];
charArray0[0] = 's';
charArray0[1] = '?';
charArray0[2] = '/';
charArray0[3] = '1';
charArray0[4] = 'B';
charArray0[5] = '>';
charArray0[6] = 'C';
charArray0[7] = 'G';
ReaderBasedJsonParser readerBasedJsonParser0 = null;
// try {
readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2678, stringReader0, (ObjectCodec) null, (CharsToNameCanonicalizer) null, charArray0, 1, 48, true);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test407() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, "expected a digit for number exponent", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 2, 34, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 2
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test408() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(3);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[5];
charArray0[0] = '\"';
charArray0[1] = 'A';
charArray0[2] = 'A';
charArray0[3] = '.';
charArray0[4] = '|';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('c' (code 99)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: java.lang.String@0000000239; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test409() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1361, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1361, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
iOContext0.releaseWriteEncodingBuffer((byte[]) null);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
char[] charArray0 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1361, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0.getValueAsString("");
assertEquals("", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1361, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000240; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test410() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1881);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = 'o';
charArray0[1] = '-';
charArray0[2] = '$';
int int0 = stringReader0.read();
assertEquals(120, int0);
charArray0[3] = '*';
charArray0[4] = 'd';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-1418), 1881, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'o', '-', '$', '*', 'd', '\u0000'}, charArray0);
assertEquals(6, charArray0.length);
StringWriter stringWriter0 = new StringWriter(1881);
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
assertFalse(boolean0);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddValue(1881);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test411() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[1] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1180, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1180, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'\u0000', ')', '\u0000', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000241; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test412() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("-INF");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[8];
charArray0[0] = '6';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
charArray0[4] = '\"';
charArray0[5] = '\"';
charArray0[6] = '\"';
charArray0[7] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2197, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 98, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2197, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'6', '\"', '\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertEquals(8, charArray0.length);
readerBasedJsonParser0._skipCR();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2197, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'6', '\"', '\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(iOContext0, iOContext1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(117);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("-INF");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
JsonToken jsonToken0 = readerBasedJsonParser0.nextToken();
assertEquals(JsonToken.VALUE_STRING, jsonToken0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(jsonToken0.isStructStart());
assertNull(jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
assertEquals(6, jsonToken0.id());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2197, readerBasedJsonParser0.getFeatureMask());
assertEquals(4L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(6, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_STRING, readerBasedJsonParser0.getCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertTrue(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'6', '\"', '\"', '\"', '\"', '\"', '\"', '\"'}, charArray0);
assertEquals(8, charArray0.length);
assertNotSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('\"' (code 34)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000242; line: 2, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test413() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, "z4A2tRBsgE-", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext0);
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext1, iOContext0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
StringReader stringReader1 = new StringReader("?|h");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(11);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 2, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 123, 3, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// Undeclared exception!
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test414() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("x|>ZM?cnK");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[5];
charArray0[1] = '(';
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1000, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 256, 1014, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\u0000', '(', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(0, int0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'\u0000', '(', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
assertSame(iOContext0, iOContext1);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getCurrentLocation();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(jsonLocation0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1000, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals(256L, jsonLocation0.getCharOffset());
assertEquals(257, jsonLocation0.getColumnNr());
assertArrayEquals(new char[] {'\u0000', '(', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
assertSame(iOContext0, iOContext1);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextLongValue(33);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 256
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test415() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
int int0 = 56;
char[] charArray0 = iOContext0.allocNameCopyBuffer(1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(charArray0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(200, charArray0.length);
assertSame(iOContext0, iOContext1);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000243; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test416() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
String string0 = "77c:e@";
StringReader stringReader0 = new StringReader("77c:e@");
assertNotNull(stringReader0);
long long0 = stringReader0.skip((-9223372036854775808L));
assertEquals(0L, long0);
char[] charArray0 = iOContext0.allocNameCopyBuffer((-1337));
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 42, 2004, true);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(200, charArray0.length);
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000244; line: 1, column: 44]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test417() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[1] = ')';
charArray0[2] = '';
charArray0[3] = '^';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'\u0000', ')', '', '^'}, charArray0);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("&}\"9Ea&j2oN:zF|5");
assertNotNull(serializedString0);
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.getValue());
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.toString());
assertEquals(17, serializedString0.charLength());
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal unquoted character ((CTRL-CHAR, code 0)): has to be escaped using backslash to be included in string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000245; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test418() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-4228));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = '|';
charArray0[1] = '|';
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
charArray0[2] = '.';
charArray0[3] = 'v';
charArray0[4] = '.';
charArray0[5] = '.';
charArray0[6] = '.';
charArray0[7] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3294, 1, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'|', '|', '.', 'v', '.', '.', '.', '.'}, charArray0);
assertEquals(8, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
stringReader0.reset();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2944, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2944, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
// try {
readerBasedJsonParser1.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000246; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test419() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
charArray0[0] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2506, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2506, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
readerBasedJsonParser0._skipCR();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2506, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNotSame(stringReader1, stringReader0);
boolean boolean0 = readerBasedJsonParser0.nextFieldName((SerializableString) null);
assertFalse(boolean0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2506, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(stringReader1, stringReader0);
char[] charArray1 = readerBasedJsonParser0.getTextCharacters();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(charArray1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(JsonToken.VALUE_NUMBER_FLOAT, readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(8, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(2506, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'-', 'I', 'n', 'f', 'i', 'n', 'i', 't', 'y'}, charArray1);
assertEquals(9, charArray1.length);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charArray1, charArray0);
boolean boolean1 = readerBasedJsonParser0.nextFieldName((SerializableString) null);
assertFalse(boolean1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertTrue(boolean1 == boolean0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(2, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(2506, readerBasedJsonParser0.getFeatureMask());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(stringReader1, stringReader0);
}
@Test(timeout = 4000)
public void test420() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[6];
charArray0[0] = '2';
charArray0[1] = 'r';
charArray0[2] = 'W';
charArray0[3] = 'k';
charArray0[4] = '8';
charArray0[5] = '#';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 29, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 3070, 2, true);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(29, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'2', 'r', 'W', 'k', '8', '#'}, charArray0);
assertEquals(6, charArray0.length);
Object object0 = readerBasedJsonParser0.getTypeId();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(object0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(29, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'2', 'r', 'W', 'k', '8', '#'}, charArray0);
assertEquals(6, charArray0.length);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
StringReader stringReader0 = new StringReader("No digit following minus sign");
assertNotNull(stringReader0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, (-1715), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser1);
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals((-1715), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
char[] charArray1 = readerBasedJsonParser1.getTextCharacters();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNull(charArray1);
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals((-1715), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
}
@Test(timeout = 4000)
public void test421() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
String string0 = "}Pr";
StringReader stringReader0 = new StringReader("}Pr");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(12000);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2487, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(2487, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000247; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test422() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
int int0 = 101;
String string0 = "}_liH$?B:";
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
boolean boolean2 = FileSystemHandling.shouldAllThrowIOExceptions();
assertFalse(boolean2);
assertFalse(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
boolean boolean3 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "}_liH$?B:");
assertFalse(boolean3);
assertTrue(boolean3 == boolean1);
assertFalse(boolean3 == boolean0);
assertTrue(boolean3 == boolean2);
IOContext iOContext2 = new IOContext(bufferRecycler0, "JcEpJE*(,qpo", true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-637), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext1.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-637), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected close marker '}': expected ']' (for ROOT starting at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 0])
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000248; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test423() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "expected a digit for number exponent");
assertFalse(boolean0);
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
int int0 = readerBasedJsonParser0.nextIntValue(45);
assertEquals(45, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(1L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertTrue(readerBasedJsonParser0.hasCurrentToken());
assertEquals(2, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(JsonToken.VALUE_FALSE, readerBasedJsonParser0.getCurrentToken());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000249; line: 1, column: 16]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test424() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(98);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'K';
StringReader stringReader1 = new StringReader("false");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader2 = new StringReader("");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 45, stringReader2, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
int int0 = readerBasedJsonParser0.nextIntValue(0);
assertEquals(0, int0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
long long0 = readerBasedJsonParser0.nextLongValue((-9223372036854775808L));
assertEquals((-9223372036854775808L), long0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(stringReader2, stringReader0);
assertNotSame(stringReader2, stringReader1);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000250; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test425() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[0];
int int0 = stringReader0.read(charArray0);
assertEquals(0, int0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
ObjectCodec objectCodec0 = null;
int int1 = 10;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 10, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 33, 35, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(10, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(35, "9XU{:<ELw");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 33
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test426() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 43, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 43, 200, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(43, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddName(43);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 43
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test427() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
assertFalse(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-550));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
assertFalse(boolean1 == boolean0);
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in character escape sequence
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000251; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test428() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, fileSystemHandling0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
int int0 = stringReader0.read(charArray0);
assertEquals(1, int0);
assertArrayEquals(new char[] {'9'}, charArray0);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-1352));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 106, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(106, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'9'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: org.evosuite.runtime.testdata.FileSystemHandling@0000000252; line: 1, column: 10]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test429() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = '\"';
charArray0[1] = ':';
charArray0[2] = '\"';
charArray0[3] = ':';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4325, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, (-2110), false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(4325, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\"', ':', '\"', ':'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000253; line: 1, column: -2089]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test430() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[5];
charArray0[0] = 'b';
charArray0[1] = 'Y';
charArray0[2] = ':';
charArray0[3] = '#';
charArray0[4] = '@';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, (Reader) null, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
String string0 = readerBasedJsonParser0.nextTextValue();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
long long0 = readerBasedJsonParser0.nextLongValue(3);
assertEquals(3L, long0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
}
@Test(timeout = 4000)
public void test431() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'QWnqca4=");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[7];
charArray0[0] = 'T';
charArray0[1] = ':';
charArray0[2] = '6';
charArray0[3] = '$';
charArray0[4] = 'L';
charArray0[5] = 'o';
charArray0[6] = 'p';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-2629));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2629), stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-2629), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
String string0 = readerBasedJsonParser0.getValueAsString("'QWnqca4=");
assertEquals("'QWnqca4=", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals((-2629), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000254; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test432() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2676);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("'");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 784, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(784, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(jsonLocation0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(784, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000255; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test433() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader(" in a comment");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(108);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = 'I';
charArray0[1] = 'I';
charArray0[2] = 'I';
charArray0[3] = 'I';
charArray0[4] = 'I';
charArray0[5] = 'I';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 4, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'I', 'I', 'I', 'I', 'I', 'I'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('I' (code 73)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000256; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test434() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean2 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[0];
int int0 = stringReader0.read(charArray0);
assertEquals(0, int0);
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 33, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 3
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test435() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
charArray0[0] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '9';
int int1 = stringReader0.read(charArray1);
assertEquals(1, int1);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(int1 == int0);
assertArrayEquals(new char[] {'n'}, charArray1);
assertEquals(1, charArray1.length);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charArray1, charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray1, 3, (-3136), true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertArrayEquals(new char[] {'n'}, charArray1);
assertEquals(1, charArray1.length);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '-Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000257; line: 1, column: -3125]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test436() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader2 = new StringReader("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1462), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-1462), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Non-standard token '-Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000258; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test437() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = 'I';
charArray0[1] = ')';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1180, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1180, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'I', ')', '\u0000', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('e' (code 101)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000259; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test438() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler1, "expected a digit for number exponent", false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(jsonLocation0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext0, iOContext2);
ReaderBasedJsonParser readerBasedJsonParser1 = null;
// try {
readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
// fail("Expecting exception: IllegalStateException");
// } catch(IllegalStateException e) {
// //
// // Trying to call same allocXxx() method second time
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test439() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(3);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[5];
charArray0[0] = '\"';
charArray0[1] = 'A';
charArray0[2] = 'x';
charArray0[3] = '.';
charArray0[4] = '|';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 49, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2367, (-4228), true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(49, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'\"', 'A', 'x', '.', '|'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'com': was expecting ('true', 'false' or 'null')
// // at [Source: java.lang.String@0000000260; line: 1, column: -4224]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test440() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
boolean boolean1 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
String string0 = "}_liH$?B:";
StringReader stringReader0 = new StringReader("}_liH$?B:");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
boolean boolean2 = FileSystemHandling.shouldAllThrowIOExceptions();
assertFalse(boolean2);
assertTrue(boolean2 == boolean1);
assertFalse(boolean2 == boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer1.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
boolean boolean3 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "}_liH$?B:");
assertFalse(boolean3);
assertTrue(boolean3 == boolean2);
assertTrue(boolean3 == boolean1);
assertFalse(boolean3 == boolean0);
charArray0[0] = 'f';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 101, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 1, 1, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(101, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'f'}, charArray0);
assertEquals(1, charArray0.length);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('}', char0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(101, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'}'}, charArray0);
assertEquals(1, charArray0.length);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000261; line: 1, column: 12]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test441() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = 'I';
charArray0[1] = ')';
String string0 = "";
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader1, objectCodec0, charsToNameCanonicalizer0, charArray0, 91, ')', false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'I', ')', '\u0000', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
long long0 = readerBasedJsonParser0.nextLongValue(33);
assertEquals(33L, long0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'I', ')', '\u0000', '\u0000'}, charArray0);
assertEquals(4, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(stringReader1, stringReader0);
Base64Variant base64Variant0 = null;
// try {
base64Variant0 = new Base64Variant("K/", "expected a digit for number exponent", false, '7', 1);
// fail("Expecting exception: IllegalArgumentException");
// } catch(IllegalArgumentException e) {
// //
// // Base64Alphabet length must be exactly 64 (was 36)
// //
// verifyException("com.fasterxml.jackson.core.Base64Variant", e);
// }
}
@Test(timeout = 4000)
public void test442() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("'QWnqca4=");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[7];
charArray0[0] = 'T';
charArray0[1] = ':';
charArray0[2] = '6';
charArray0[3] = '$';
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 2, 48, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'T', ':', '6', '$', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 4, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(4, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'T', ':', '6', '$', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(7, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('$' (code 36)): Expected space separating root-level values
// // at [Source: java.lang.String@0000000262; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test443() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
Object object0 = new Object();
assertNotNull(object0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
StringReader stringReader0 = new StringReader("6.");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1608), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals((-1608), readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('.' (code 46)) in numeric value: Decimal point not followed by a digit
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000263; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test444() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("Current token (");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer1, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(iOContext0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 65, (Reader) null, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
char[] charArray0 = iOContext0.allocNameCopyBuffer(56);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charArray0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(200, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
readerBasedJsonParser0.nextToken();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string0 = readerBasedJsonParser0.getText();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
String string1 = readerBasedJsonParser0.nextFieldName();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNull(string1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(33, "8zIA!bGh,PNKN'Ue");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('!' (code 33)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000264; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test445() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("Current token (");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
int int0 = 4;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((char[]) null).when(iOContext0).allocTokenBuffer();
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 6, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(object0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertSame(object0, stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, object0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertSame(object0, stringReader0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 2, stringReader0, objectCodec1, charsToNameCanonicalizer1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(2, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
byte[] byteArray0 = iOContext2.allocBase64Buffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(byteArray0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertEquals(2000, byteArray0.length);
assertSame(stringReader0, object0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(object0, stringReader0);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)object0));
assertNotNull(stringReader1);
int int1 = stringReader1.read();
assertEquals((-1), int1);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)object0));
assertFalse(int1 == int0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(stringReader1, object0);
char[] charArray0 = iOContext2.allocNameCopyBuffer(2845);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertFalse(object0.equals((Object)stringReader1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(charArray0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(6, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertTrue(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext2.getEncoding());
assertEquals(2845, charArray0.length);
assertSame(stringReader0, object0);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(object0, stringReader0);
assertNotSame(object0, stringReader1);
assertSame(iOContext1, iOContext2);
assertSame(iOContext2, iOContext1);
// try {
readerBasedJsonParser1.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'Current': was expecting ('true', 'false' or 'null')
// // at [Source: java.io.StringReader@0000000265; line: 1, column: 8]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test446() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext1 = new IOContext(bufferRecycler0, stringReader0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
int int0 = 65;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 4, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(4, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
char[] charArray0 = iOContext0.allocNameCopyBuffer(55);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(200, charArray0.length);
assertNotSame(iOContext0, iOContext1);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('B' (code 66)): Expected space separating root-level values
// // at [Source: java.io.StringReader@0000000266; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test447() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[7];
charArray0[0] = 'V';
charArray0[1] = 'p';
charArray0[2] = 'V';
charArray0[3] = '(';
charArray0[4] = ')';
charArray0[5] = 'i';
charArray0[6] = '\"';
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
TextBuffer textBuffer0 = iOContext1.constructTextBuffer();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(textBuffer0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, '(', stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
StringReader stringReader1 = (StringReader)readerBasedJsonParser0.getInputSource();
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(stringReader1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(stringReader1, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(stringReader0, stringReader1);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader1, false);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertNull(iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(iOContext3);
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertSame(stringReader1, stringReader0);
assertNotSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(stringReader0, stringReader1);
char[] charArray1 = new char[8];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'm';
long long0 = readerBasedJsonParser0._nameStartOffset;
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 217, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(217, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(0, "Leading zeroes not allowed");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)): was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000267; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test448() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
char[] charArray0 = new char[4];
charArray0[0] = 'p';
charArray0[1] = '9';
charArray0[2] = '9';
charArray0[3] = 'p';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 44, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 2, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(44, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'p', '9', '9', 'p'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0._handleOddName(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 2)): was expecting either valid name character (for unquoted name) or double-quote (for quoted) to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000268; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test449() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
assertFalse(boolean0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_BE;
iOContext0.setEncoding(jsonEncoding1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(55);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1, (char[]) null, 1415, 1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
ObjectCodec objectCodec0 = readerBasedJsonParser0.getCodec();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNull(objectCodec0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextLongValue(0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test450() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int0 = stringReader0.read();
assertEquals(41, int0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-3096), stringReader0, objectCodec1, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals((-3096), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 127)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000269; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test451() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("x|>ZM?cnK");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[5];
charArray0[1] = '(';
charArray0[2] = '*';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-4), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, (-4), true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals((-4), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'\u0000', '(', '*', '\u0000', '\u0000'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0._parsePosNumber((-2323));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('x' (code 120)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000270; line: 1, column: -2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test452() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
String string0 = "t-l8Np,4Z";
StringReader stringReader0 = new StringReader("t-l8Np,4Z");
assertNotNull(stringReader0);
char[] charArray0 = new char[5];
charArray0[0] = '0';
charArray0[1] = 'h';
charArray0[2] = 'm';
charArray0[3] = 'L';
charArray0[4] = 'L';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 837, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 4938, 0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(837, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertArrayEquals(new char[] {'0', 'h', 'm', 'L', 'L'}, charArray0);
assertEquals(5, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(jsonLocation0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(837, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals(1, jsonLocation0.getLineNr());
assertArrayEquals(new char[] {'0', 'h', 'm', 'L', 'L'}, charArray0);
assertEquals(5, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test453() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
String string0 = "RfT[\"W J";
StringReader stringReader0 = new StringReader("RfT[\"W J");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[4];
charArray0[0] = 'L';
charArray0[1] = 'L';
charArray0[2] = 'o';
charArray0[3] = 'm';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 39, 78, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'L', 'L', 'o', 'm'}, charArray0);
assertEquals(4, charArray0.length);
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(jsonLocation0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertArrayEquals(new char[] {'L', 'L', 'o', 'm'}, charArray0);
assertEquals(4, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 39
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test454() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertFalse(boolean1);
assertFalse(boolean1 == boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
String string0 = "";
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
int int0 = stringReader0.read();
assertEquals((-1), int0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(13);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
SerializedString serializedString0 = new SerializedString(": was expecting closing quote for a string value");
assertNotNull(serializedString0);
assertEquals(48, serializedString0.charLength());
assertEquals(": was expecting closing quote for a string value", serializedString0.toString());
assertEquals(": was expecting closing quote for a string value", serializedString0.getValue());
boolean boolean2 = readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
assertFalse(boolean2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertTrue(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(48, serializedString0.charLength());
assertEquals(": was expecting closing quote for a string value", serializedString0.toString());
assertEquals(": was expecting closing quote for a string value", serializedString0.getValue());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-inputNo digit following minus sign
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000271; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test455() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(98);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'K';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 544, 33, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'K'}, charArray0);
assertEquals(1, charArray0.length);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec1, charsToNameCanonicalizer2, charArray0, 3, (-907), true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(33, readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'K'}, charArray0);
assertEquals(1, charArray0.length);
SerializedString serializedString0 = new SerializedString("6pB^Vi'R9^Ef");
assertNotNull(serializedString0);
assertEquals("6pB^Vi'R9^Ef", serializedString0.toString());
assertEquals("6pB^Vi'R9^Ef", serializedString0.getValue());
assertEquals(12, serializedString0.charLength());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test456() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
boolean boolean0 = FileSystemHandling.createFolder((EvoSuiteFile) null);
assertFalse(boolean0);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("('true', 'false' or 'null')");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 91, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(91, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
iOContext1.releaseWriteEncodingBuffer((byte[]) null);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("", (-3153));
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test457() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "Q#+T>.", false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
StringReader stringReader0 = new StringReader("t");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(charArray0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(4000, charArray0.length);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
JsonLocation jsonLocation0 = readerBasedJsonParser0.getTokenLocation();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(jsonLocation0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, jsonLocation0.getLineNr());
assertEquals((-1L), jsonLocation0.getByteOffset());
assertEquals(0, jsonLocation0.getColumnNr());
assertEquals((-1L), jsonLocation0.getCharOffset());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 't': was expecting 'null', 'true', 'false' or NaN
// // at [Source: java.lang.String@0000000272; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test458() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2000, byteArray0.length);
int int0 = stringReader0.read();
assertEquals(52, int0);
char[] charArray0 = new char[5];
charArray0[0] = '?';
charArray0[1] = 'o';
charArray0[2] = 'w';
charArray0[3] = '+';
charArray0[4] = 'h';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 91, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 15, 2, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(91, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'?', 'o', 'w', '+', 'h'}, charArray0);
assertEquals(5, charArray0.length);
char char0 = readerBasedJsonParser1._decodeEscaped();
assertEquals('B', char0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(91, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertArrayEquals(new char[] {'B', ')', '', '+', 'h'}, charArray0);
assertEquals(5, charArray0.length);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("", 33);
// fail("Expecting exception: StringIndexOutOfBoundsException");
// } catch(StringIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test459() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("&n!fq*J1idC");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
char[] charArray0 = new char[9];
charArray0[0] = '_';
charArray0[1] = 'E';
charArray0[2] = '-';
charArray0[3] = '-';
charArray0[4] = '4';
charArray0[5] = 'Y';
charArray0[6] = 'B';
charArray0[7] = 'd';
charArray0[8] = '4';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-1737), 6, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'_', 'E', '-', '-', '4', 'Y', 'B', 'd', '4'}, charArray0);
assertEquals(9, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._reportInvalidToken("*", "*");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test460() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'QWnqca4=");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("'QWnqca4=");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(192);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2774), stringReader1, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2774), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
Object object0 = readerBasedJsonParser0.getInputSource();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(object0.equals((Object)stringReader0));
assertNotNull(object0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals((-2774), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertSame(stringReader1, object0);
assertNotSame(stringReader1, stringReader0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertSame(object0, stringReader1);
assertNotSame(object0, stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
IOContext iOContext2 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 48, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)object0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(48, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (''' (code 39)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000273; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test461() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, (String) null);
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("'");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
String string0 = readerBasedJsonParser0.getValueAsString("'");
assertEquals("'", string0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(string0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (''' (code 39)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: UNKNOWN; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test462() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.JsonLocation");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
stringReader0.close();
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "com.fasterxml.jackson.core.JsonLocation");
assertFalse(boolean0);
boolean boolean1 = stringReader0.markSupported();
assertTrue(boolean1);
assertFalse(boolean1 == boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 80, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
boolean boolean2 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean2);
assertFalse(boolean2 == boolean0);
assertTrue(boolean2 == boolean1);
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test463() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(bufferRecycler0);
Object object0 = new Object();
assertNotNull(object0);
IOContext iOContext0 = new IOContext(bufferRecycler0, object0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("i~s6");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("Cr");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[3];
charArray0[0] = 'W';
charArray0[1] = 'n';
charArray0[2] = 'n';
int int0 = stringReader1.read(charArray0);
assertEquals(3, int0);
assertFalse(stringReader1.equals((Object)stringReader0));
assertArrayEquals(new char[] {'C', 'r', ''}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(stringReader1, stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
int int1 = 47;
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
assertFalse(stringReader0.equals((Object)stringReader1));
assertNotSame(stringReader0, stringReader1);
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized character escape 'i' (code 105)
// // at [Source: java.lang.Object@0000000274; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test464() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("Z|IRQ?f?QzmQ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
assertFalse(boolean0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 12000, (-948), false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read -948
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test465() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, "vRXWH", true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4868);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[6];
charArray0[0] = 'o';
charArray0[1] = 'U';
charArray0[2] = '8';
charArray0[3] = 'K';
charArray0[4] = 'q';
charArray0[5] = '7';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 33, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'o', 'U', '8', 'K', 'q', '7'}, charArray0);
assertEquals(6, charArray0.length);
StringWriter stringWriter0 = new StringWriter();
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
// Undeclared exception!
// try {
readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.StringWriter", e);
// }
}
@Test(timeout = 4000)
public void test466() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[1] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-35), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 33, 1, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-35), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'L', '$', '\u0000'}, charArray0);
assertEquals(3, charArray0.length);
byte[] byteArray0 = iOContext0.allocReadIOBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(byteArray0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
StringWriter stringWriter0 = new StringWriter(1);
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
StringWriter stringWriter1 = stringWriter0.append((CharSequence) "L%zu=\"`?&: ap");
assertNotNull(stringWriter1);
assertEquals("L%zu=\"`?&: ap", stringWriter0.toString());
assertEquals("L%zu=\"`?&: ap", stringWriter1.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter1, stringWriter0);
StringWriter stringWriter2 = stringWriter1.append((CharSequence) "L%zu=\"`?&: ap", 2, 9);
assertNotNull(stringWriter2);
assertEquals("L%zu=\"`?&: apzu=\"`?&", stringWriter0.toString());
assertEquals("L%zu=\"`?&: apzu=\"`?&", stringWriter1.toString());
assertEquals("L%zu=\"`?&: apzu=\"`?&", stringWriter2.toString());
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter0, stringWriter2);
assertSame(stringWriter1, stringWriter0);
assertSame(stringWriter1, stringWriter2);
assertSame(stringWriter2, stringWriter1);
assertSame(stringWriter2, stringWriter0);
int int0 = readerBasedJsonParser0.releaseBuffered((Writer) stringWriter2);
assertEquals(0, int0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-35), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals("L%zu=\"`?&: apzu=\"`?&", stringWriter0.toString());
assertEquals("L%zu=\"`?&: apzu=\"`?&", stringWriter1.toString());
assertEquals("L%zu=\"`?&: apzu=\"`?&", stringWriter2.toString());
assertArrayEquals(new char[] {'L', '$', '\u0000'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertSame(stringWriter0, stringWriter1);
assertSame(stringWriter0, stringWriter2);
assertSame(stringWriter1, stringWriter0);
assertSame(stringWriter1, stringWriter2);
assertSame(stringWriter2, stringWriter1);
assertSame(stringWriter2, stringWriter0);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'L': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000275; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test467() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("x)u]v:mt /");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
int int0 = 1881;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1881);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = 'o';
charArray0[1] = '\"';
charArray0[2] = '$';
int int1 = stringReader0.read();
assertEquals(120, int1);
assertFalse(int1 == int0);
charArray0[3] = '*';
charArray0[4] = 'd';
charArray0[5] = '=';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, (-1418), 1881, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'o', '\"', '$', '*', 'd', '='}, charArray0);
assertEquals(6, charArray0.length);
StringWriter stringWriter0 = new StringWriter(1881);
assertNotNull(stringWriter0);
assertEquals("", stringWriter0.toString());
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, false);
assertFalse(boolean0);
// Undeclared exception!
// try {
readerBasedJsonParser0.releaseBuffered((Writer) stringWriter0);
// fail("Expecting exception: IndexOutOfBoundsException");
// } catch(IndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("java.io.StringWriter", e);
// }
}
@Test(timeout = 4000)
public void test468() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = '<';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3825, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 39, 46, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(stringReader1.equals((Object)stringReader2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(3825, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertArrayEquals(new char[] {'<', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(6, charArray0.length);
SerializedString serializedString0 = new SerializedString("-Infinity");
assertNotNull(serializedString0);
assertEquals(9, serializedString0.charLength());
assertEquals("-Infinity", serializedString0.getValue());
assertEquals("-Infinity", serializedString0.toString());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 39
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test469() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
StringReader stringReader0 = new StringReader("true");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-77));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("true");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader1, objectCodec0, charsToNameCanonicalizer1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
JsonToken jsonToken0 = JsonToken.END_ARRAY;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("]", string0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
String string1 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("]", string1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(string1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNotSame(iOContext0, iOContext1);
assertNotSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(stringReader1, stringReader0);
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: com.fasterxml.jackson.core.io.IOContext@0000000276; line: 1, column: 9]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test470() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
String string0 = "expected a digit for number exponent";
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = 'I';
charArray0[1] = ')';
char char0 = '';
charArray0[2] = '';
charArray0[3] = '^';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'I', ')', '', '^'}, charArray0);
assertEquals(4, charArray0.length);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
SerializedString serializedString0 = new SerializedString("&}\"9Ea&j2oN:zF|5");
assertNotNull(serializedString0);
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.toString());
assertEquals(17, serializedString0.charLength());
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.getValue());
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000277; line: 1, column: 42]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test471() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("Cu*ren| token #");
assertNotNull(stringReader0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding1);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertNotNull(iOContext2);
assertEquals(JsonEncoding.UTF16_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_LE, iOContext1.getEncoding());
assertEquals(JsonEncoding.UTF16_LE, iOContext2.getEncoding());
assertFalse(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext2, iOContext0);
assertSame(iOContext2, iOContext1);
iOContext1.setEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(jsonEncoding0.equals((Object)jsonEncoding1));
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext2);
assertSame(iOContext0, iOContext1);
assertNotSame(jsonEncoding0, jsonEncoding1);
assertSame(iOContext1, iOContext0);
assertSame(iOContext1, iOContext2);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char char0 = 'v';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
// try {
readerBasedJsonParser0._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000278; line: 1, column: 31]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test472() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("kh!\"hu)F88h");
assertNotNull(stringReader0);
charsToNameCanonicalizer0.release();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 35, (-1858), true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test473() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[1] = '$';
charArray0[2] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 3, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertArrayEquals(new char[] {'L', '$', '$'}, charArray0);
assertEquals(3, charArray0.length);
// try {
readerBasedJsonParser0.getFloatValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not numeric, can not use numeric value accessors
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000279; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test474() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("-Infinity");
assertNotNull(stringReader0);
char[] charArray0 = new char[2];
charArray0[0] = ']';
int int0 = stringReader0.read(charArray0);
assertEquals(2, int0);
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray1 = new char[1];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = ']';
int int1 = stringReader0.read(charArray1);
assertEquals(1, int1);
assertFalse(charArray1.equals((Object)charArray0));
assertFalse(int1 == int0);
assertArrayEquals(new char[] {'n'}, charArray1);
assertEquals(1, charArray1.length);
assertNotSame(charArray1, charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild((-873));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 45, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1018, 2, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charArray0.equals((Object)charArray1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(45, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'-', 'I'}, charArray0);
assertEquals(2, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddName(1018);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test475() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = 'p';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray1 = new char[4];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'm';
charArray1[1] = '9';
charArray1[2] = 'p';
charArray1[3] = '9';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 44, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray1, 50, 33, false);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(44, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'m', '9', 'p', '9'}, charArray1);
assertEquals(4, charArray1.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._handleOddName((-4699));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -4699
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test476() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[7];
charArray0[0] = 'V';
charArray0[1] = 'p';
charArray0[2] = 'V';
charArray0[3] = '(';
charArray0[4] = ')';
charArray0[5] = 'i';
charArray0[6] = '%';
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
TextBuffer textBuffer0 = iOContext1.constructTextBuffer();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(textBuffer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, textBuffer0.size());
assertEquals(0, textBuffer0.getTextOffset());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
String string0 = "Leading zeroes not allowed";
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, '(', stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader1 = (StringReader)readerBasedJsonParser0.getInputSource();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(stringReader1);
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertSame(stringReader1, stringReader0);
assertSame(iOContext0, iOContext1);
assertSame(stringReader0, stringReader1);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader1, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertFalse(iOContext0.equals((Object)iOContext2));
assertNotNull(iOContext3);
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertSame(stringReader1, stringReader0);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertNotSame(iOContext3, iOContext1);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext0);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(iOContext0, iOContext2);
assertSame(stringReader0, stringReader1);
char[] charArray1 = new char[8];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'm';
long long0 = stringReader0.skip(2);
assertEquals(2L, long0);
assertSame(stringReader0, stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 217, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertEquals(217, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(127, "Leading zeroes not allowed");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('z' (code 122)): was expecting a colon to separate field name and value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000280; line: 1, column: 8]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test477() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("com.fahterxml.jackson.core.JsonLocation");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.size());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "com.fahterxml.jackson.core.JsonLocation");
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 80, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
assertFalse(boolean1 == boolean0);
ByteArrayBuilder byteArrayBuilder0 = new ByteArrayBuilder(bufferRecycler0, 0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(byteArrayBuilder0);
assertEquals(0, byteArrayBuilder0.getCurrentSegmentLength());
// try {
readerBasedJsonParser0.readBinaryValue((OutputStream) byteArrayBuilder0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000281; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test478() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(98);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'K';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 544, 33, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'K'}, charArray0);
assertEquals(1, charArray0.length);
MockFileOutputStream mockFileOutputStream0 = new MockFileOutputStream("L*c`>T\nk");
assertNotNull(mockFileOutputStream0);
// try {
readerBasedJsonParser0.readBinaryValue((OutputStream) mockFileOutputStream0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000282; line: 1, column: 545]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test479() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader0 = new StringReader("string value");
assertNotNull(stringReader0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(iOContext1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
char[] charArray0 = new char[6];
charArray0[0] = 'n';
charArray0[1] = ')';
charArray0[2] = 'O';
charArray0[3] = 'U';
charArray0[4] = 'A';
charArray0[5] = '|';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-4161), 0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertArrayEquals(new char[] {'n', ')', 'O', 'U', 'A', '|'}, charArray0);
assertEquals(6, charArray0.length);
// try {
readerBasedJsonParser0.getBinaryValue((Base64Variant) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Current token (null) not VALUE_STRING or VALUE_EMBEDDED_OBJECT, can not access as binary
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000283; line: 1, column: -4160]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test480() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4000, stringReader0, objectCodec0, charsToNameCanonicalizer0);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(4000, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000284; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test481() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
char[] charArray0 = new char[2];
charArray0[0] = 'L';
charArray0[1] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 16, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, (-35), false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'L', '.'}, charArray0);
assertEquals(2, charArray0.length);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: UNKNOWN; line: 1, column: -32]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test482() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3192);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, (-324), true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(1503, (String) null);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('\u05DF' (code 1503 / 0x5df)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000285; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test483() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("Current token (");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
boolean boolean0 = stringReader0.markSupported();
assertTrue(boolean0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer1, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(iOContext0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 65, (Reader) null, objectCodec0, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
char[] charArray0 = iOContext0.allocNameCopyBuffer(56);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charArray0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(200, charArray0.length);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
readerBasedJsonParser0.nextToken();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 3377, stringReader0, objectCodec1, charsToNameCanonicalizer0, charArray0, 56, 48, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals(3377, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(200, charArray0.length);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(0, int0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(65, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertTrue(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
}
@Test(timeout = 4000)
public void test484() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(758);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2551, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 33, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(2551, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test485() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
StringReader stringReader0 = new StringReader("!uIK8+6\"6_To");
assertNotNull(stringReader0);
char[] charArray0 = iOContext0.allocConcatBuffer();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(charArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(4000, charArray0.length);
boolean boolean0 = FileSystemHandling.setPermissions((EvoSuiteFile) null, true, false, false);
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-2), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 83, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-2), readerBasedJsonParser0.getFeatureMask());
assertEquals(4000, charArray0.length);
String string0 = "Fdv7";
String string1 = readerBasedJsonParser0.getValueAsString(";&T6I");
assertEquals(";&T6I", string1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(string1.equals((Object)string0));
assertNotNull(string1);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals((-2), readerBasedJsonParser0.getFeatureMask());
assertEquals(4000, charArray0.length);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000286; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test486() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[1] = ')';
charArray0[2] = '';
charArray0[3] = '^';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'\u0000', ')', '', '^'}, charArray0);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("&}\"9Ea&j2oN:zF|5");
assertNotNull(serializedString0);
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.toString());
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.getValue());
assertEquals(17, serializedString0.charLength());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Illegal character ((CTRL-CHAR, code 0)): only regular white space (\\r, \\n, \\t) is allowed between tokens
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000287; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test487() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[6];
charArray0[0] = '<';
charArray0[1] = 'U';
charArray0[2] = '>';
charArray0[3] = '`';
charArray0[4] = 'D';
charArray0[5] = 'z';
int int0 = stringReader2.read(charArray0);
assertEquals(6, int0);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertArrayEquals(new char[] {'_', '&', 'x', '', '1', '6'}, charArray0);
assertEquals(6, charArray0.length);
assertNotSame(stringReader2, stringReader1);
assertNotSame(stringReader2, stringReader0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'cUXB': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000288; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test488() throws Throwable {
boolean boolean0 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean0);
StringReader stringReader0 = new StringReader("Cn");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
char[] charArray0 = new char[2];
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
charArray0[0] = '^';
charArray0[1] = 'x';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 47, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 1, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertNotNull(readerBasedJsonParser0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'^', 'x'}, charArray0);
assertEquals(2, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test489() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("expected a valid value (number, String, array, object, 'true', 'false' or 'null')");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3192);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, (-324), true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF8, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF8, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentName());
// Undeclared exception!
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test490() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(33, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
// try {
readerBasedJsonParser0.nextTextValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '_': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000289; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test491() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(37);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
StringReader stringReader1 = new StringReader("5i)cYm]rq");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
char[] charArray0 = new char[9];
charArray0[0] = '@';
charArray0[1] = 'U';
charArray0[2] = '';
charArray0[3] = 'p';
charArray0[4] = '/';
StringReader stringReader2 = new StringReader("4B)");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
char[] charArray1 = new char[5];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = '@';
charArray1[1] = '/';
charArray1[2] = '3';
charArray1[3] = '';
charArray1[4] = 'p';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 61, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0, charArray1, 0, 117, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(charArray1.equals((Object)charArray0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(61, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertArrayEquals(new char[] {'@', '/', '3', '', 'p'}, charArray1);
assertEquals(5, charArray1.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('@' (code 64)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000290; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test492() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(1);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArray0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
StringReader stringReader1 = new StringReader("0Ur@<ht#UWk<g");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
char[] charArray0 = new char[1];
charArray0[0] = 'j';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 73, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 3, 33, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(73, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'j'}, charArray0);
assertEquals(1, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, (-690), stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 33, 32, true);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-690), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertArrayEquals(new char[] {'j'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser1._parsePosNumber(4);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('c' (code 99)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000291; line: 1, column: 34]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test493() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 2, (-4699), false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// try {
readerBasedJsonParser0._handleInvalidNumberStart(33, false);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('!' (code 33)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: java.lang.String@0000000292; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test494() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
assertNotNull(fileSystemHandling0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, fileSystemHandling0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("9XU{:<ELw");
assertNotNull(stringReader0);
char[] charArray0 = new char[1];
int int0 = stringReader0.read(charArray0);
assertEquals(1, int0);
assertArrayEquals(new char[] {'9'}, charArray0);
assertEquals(1, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1180, 73, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertArrayEquals(new char[] {'9'}, charArray0);
assertEquals(1, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('X' (code 88)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: org.evosuite.runtime.testdata.FileSystemHandling@0000000293; line: 1, column: 75]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test495() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
assertNotNull(stringReader0);
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[2];
charArray0[0] = '.';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 16, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 47, 16, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext0.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(16, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'.', '\u0000'}, charArray0);
assertEquals(2, charArray0.length);
StringReader stringReader1 = new StringReader("V,]Y,:l\"`#M");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 3, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(iOContext1.equals((Object)iOContext0));
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertNull(iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(3, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
// try {
readerBasedJsonParser0._parsePosNumber((-2828));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (')' (code 41)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000294; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test496() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
String string0 = "'wqTx8l6WA~Kh<1U";
StringReader stringReader0 = new StringReader("'wqTx8l6WA~Kh<1U");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[4];
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
charArray0[0] = 'P';
charArray0[1] = 'u';
charArray0[2] = '0';
charArray0[3] = '<';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 123, 3, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertArrayEquals(new char[] {'P', 'u', '0', '<'}, charArray0);
assertEquals(4, charArray0.length);
// try {
readerBasedJsonParser0._parseNegNumber();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (''' (code 39)) in numeric value: expected digit (0-9) to follow minus sign, for valid numeric value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000295; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test497() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[6];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 47, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-1723), 3, false);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(6, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("-Infinity", (-1182));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1723
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test498() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("{");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-4267), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 1, 33, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals((-4267), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
// Undeclared exception!
// try {
readerBasedJsonParser0._reportInvalidToken("");
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test499() throws Throwable {
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "");
assertFalse(boolean0);
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext1);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
char[] charArray0 = new char[1];
charArray0[0] = 'x';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 117, 2507, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertArrayEquals(new char[] {'x'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 117
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test500() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild((-307));
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
char[] charArray0 = new char[1];
charArray0[0] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57, stringReader0, objectCodec0, charsToNameCanonicalizer3, charArray0, 47, 108, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(57, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'$'}, charArray0);
assertEquals(1, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 47
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test501() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer0.makeChild(33);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.JsonLocation");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer3 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer3.equals((Object)charsToNameCanonicalizer2));
assertNotNull(charsToNameCanonicalizer3);
assertEquals(64, charsToNameCanonicalizer3.bucketCount());
assertEquals(0, charsToNameCanonicalizer3.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer3.hashSeed());
assertEquals(0, charsToNameCanonicalizer3.size());
assertFalse(charsToNameCanonicalizer3.maybeDirty());
assertEquals(0, charsToNameCanonicalizer3.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer3, charsToNameCanonicalizer2);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "QF,792hg5qniw");
assertFalse(boolean0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 80, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
boolean boolean1 = FileSystemHandling.shouldAllThrowIOExceptions();
assertTrue(boolean1);
assertFalse(boolean1 == boolean0);
char char0 = readerBasedJsonParser0._decodeEscaped();
assertEquals('c', char0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer3));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer3));
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(80, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer3);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer3);
JsonToken jsonToken0 = JsonToken.END_ARRAY;
assertEquals(JsonToken.END_ARRAY, jsonToken0);
assertFalse(jsonToken0.isScalarValue());
assertEquals(4, jsonToken0.id());
assertFalse(jsonToken0.isNumeric());
assertFalse(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructStart());
assertEquals("]", jsonToken0.asString());
assertTrue(jsonToken0.isStructEnd());
String string0 = "' for name";
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000296; line: 1, column: 79]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test502() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
String string0 = "tf>T{yu\"'ATx*";
StringReader stringReader0 = new StringReader("tf>T{yu\"'ATx*");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1927), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals((-1927), readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
// try {
readerBasedJsonParser0.nextIntValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'tf': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000297; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test503() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("xv>ZM?c6v");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
char[] charArray0 = new char[5];
charArray0[0] = 't';
charArray0[1] = '(';
charArray0[2] = '*';
charArray0[3] = ':';
charArray0[4] = '\"';
byte[] byteArray0 = iOContext0.allocBase64Buffer();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(byteArray0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(2000, byteArray0.length);
assertSame(iOContext0, iOContext1);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, true);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF16_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF16_BE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {'t', '(', '*', ':', '\"'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0.nextIntValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'xv': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000298; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test504() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
boolean boolean0 = true;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext1.equals((Object)iOContext0));
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNull(iOContext1.getEncoding());
String string0 = "false";
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader0 = new StringReader("false");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
StringReader stringReader1 = new StringReader("false");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
StringReader stringReader2 = new StringReader("false");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(iOContext2);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext1);
assertSame(iOContext2, iOContext0);
assertNotSame(iOContext2, iOContext1);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext2, 1592, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(iOContext2.equals((Object)iOContext1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertTrue(iOContext2.isResourceManaged());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1592, readerBasedJsonParser0.getFeatureMask());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
char[] charArray0 = new char[2];
charArray0[0] = 'g';
charArray0[1] = 'T';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 98, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, (-877), 2, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(iOContext0.equals((Object)iOContext1));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(98, readerBasedJsonParser1.getFeatureMask());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertArrayEquals(new char[] {'g', 'T'}, charArray0);
assertEquals(2, charArray0.length);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextIntValue(1);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -877
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test505() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertNotSame(bufferRecycler1, bufferRecycler0);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
boolean boolean0 = FileSystemHandling.appendLineToFile((EvoSuiteFile) null, "Operation not supported by generator of type ");
assertFalse(boolean0);
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[2] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 3, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(2, readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertArrayEquals(new char[] {'L', '\u0000', '$'}, charArray0);
assertEquals(3, charArray0.length);
CharsToNameCanonicalizer charsToNameCanonicalizer2 = charsToNameCanonicalizer1.makeChild(13);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertNotNull(charsToNameCanonicalizer2);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer2);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer0);
assertNotSame(charsToNameCanonicalizer2, charsToNameCanonicalizer1);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 1115, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer2, charArray0, 3, 50, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer2));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer0));
assertFalse(charsToNameCanonicalizer2.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer2.size());
assertFalse(charsToNameCanonicalizer2.maybeDirty());
assertEquals(64, charsToNameCanonicalizer2.bucketCount());
assertEquals(0, charsToNameCanonicalizer2.collisionCount());
assertEquals(0, charsToNameCanonicalizer2.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer2.hashSeed());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertFalse(readerBasedJsonParser1.isClosed());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertEquals(1115, readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertArrayEquals(new char[] {'L', '\u0000', '$'}, charArray0);
assertEquals(3, charArray0.length);
SerializedString serializedString0 = new SerializedString("L%zu=\"`?&: ap");
assertNotNull(serializedString0);
assertEquals(13, serializedString0.charLength());
assertEquals("L%zu=\"`?&: ap", serializedString0.getValue());
assertEquals("L%zu=\"`?&: ap", serializedString0.toString());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'L': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000299; line: 1, column: 5]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test506() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[4];
charArray0[0] = 'I';
charArray0[1] = ')';
charArray0[2] = '';
charArray0[3] = '^';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(1, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertArrayEquals(new char[] {'I', ')', '', '^'}, charArray0);
assertEquals(4, charArray0.length);
SerializedString serializedString0 = new SerializedString("&}\"9Ea&j2oN:zF|5");
assertNotNull(serializedString0);
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.getValue());
assertEquals(17, serializedString0.charLength());
assertEquals("&}\"9Ea&j2oN:zF|5", serializedString0.toString());
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'Iexpected': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000300; line: 1, column: 10]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test507() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
StringReader stringReader0 = new StringReader(", column: ");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
char[] charArray0 = new char[2];
charArray0[0] = '{';
charArray0[1] = '{';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-168), 106, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'{', '{'}, charArray0);
assertEquals(2, charArray0.length);
readerBasedJsonParser0._releaseBuffers();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'{', '{'}, charArray0);
assertEquals(2, charArray0.length);
}
@Test(timeout = 4000)
public void test508() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("*s");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[9];
charArray0[0] = 'v';
charArray0[1] = 'c';
charArray0[2] = '$';
charArray0[3] = 'q';
charArray0[4] = '!';
charArray0[5] = 'I';
charArray0[6] = 'a';
charArray0[7] = '\\';
charArray0[8] = '8';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1655, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, (-533), true);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1655, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'v', 'c', '$', 'q', '!', 'I', 'a', '\\', '8'}, charArray0);
assertEquals(9, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = (ReaderBasedJsonParser)readerBasedJsonParser0.overrideStdFeatures((-176), (-176));
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser1);
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals((-137), readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertEquals((-137), readerBasedJsonParser1.getFeatureMask());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertArrayEquals(new char[] {'v', 'c', '$', 'q', '!', 'I', 'a', '\\', '8'}, charArray0);
assertEquals(9, charArray0.length);
assertSame(readerBasedJsonParser0, readerBasedJsonParser1);
assertSame(readerBasedJsonParser1, readerBasedJsonParser0);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._handleOddValue((-2098));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input in null
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000301; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test509() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
StringReader stringReader1 = new StringReader("-Infinity");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
assertFalse(stringReader2.equals((Object)stringReader1));
assertFalse(stringReader2.equals((Object)stringReader0));
assertNotNull(stringReader2);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ObjectCodec objectCodec0 = null;
char[] charArray0 = new char[6];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 47, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-1723), 3, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader0.equals((Object)stringReader2));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(47, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertArrayEquals(new char[] {'\u0000', '\u0000', '\u0000', '\u0000', '\u0000', '\u0000'}, charArray0);
assertEquals(6, charArray0.length);
String string0 = "string value";
// Undeclared exception!
// try {
readerBasedJsonParser0._reportInvalidToken("string value");
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test510() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
StringReader stringReader0 = new StringReader("xF)Dl|&~`FT $m");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
BufferRecycler bufferRecycler1 = new BufferRecycler();
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertFalse(bufferRecycler1.equals((Object)bufferRecycler0));
assertNotNull(bufferRecycler1);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[1] = '$';
charArray0[2] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1746, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 33, 3, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(1746, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertArrayEquals(new char[] {'L', '$', '$'}, charArray0);
assertEquals(3, charArray0.length);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, (-636), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 125, 2, false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNotNull(readerBasedJsonParser1);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-636), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertArrayEquals(new char[] {'L', '$', '$'}, charArray0);
assertEquals(3, charArray0.length);
String string0 = readerBasedJsonParser1.getCurrentName();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(bufferRecycler0.equals((Object)bufferRecycler1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertNull(string0);
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertEquals((-636), readerBasedJsonParser1.getFeatureMask());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertNull(readerBasedJsonParser1.getCurrentName());
assertArrayEquals(new char[] {'L', '$', '$'}, charArray0);
assertEquals(3, charArray0.length);
assertNotSame(bufferRecycler0, bufferRecycler1);
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
assertNotSame(readerBasedJsonParser1, readerBasedJsonParser0);
// try {
readerBasedJsonParser1._handleOddValue(2);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 2)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000302; line: 1, column: 126]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test511() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, true);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertNotNull(iOContext1);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1105);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[8];
charArray0[0] = '#';
charArray0[1] = '*';
charArray0[2] = '$';
charArray0[3] = 'A';
charArray0[4] = '';
charArray0[5] = 'A';
charArray0[6] = 'S';
charArray0[7] = 'l';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, (Reader) null, objectCodec0, charsToNameCanonicalizer1, charArray0, 2459, (-2041), true);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertEquals(JsonEncoding.UTF32_LE, iOContext0.getEncoding());
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertEquals(0, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertNull(readerBasedJsonParser0.getCurrentName());
assertArrayEquals(new char[] {'#', '*', '$', 'A', '', 'A', 'S', 'l'}, charArray0);
assertEquals(8, charArray0.length);
// try {
readerBasedJsonParser0._handleOddValue(2459);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '\u099B': was expecting ('true', 'false' or 'null')
// // at [Source: UNKNOWN; line: 1, column: 419]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test512() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(bufferRecycler0);
char[] charArray0 = new char[7];
charArray0[0] = 'V';
charArray0[1] = 'p';
charArray0[2] = 'V';
charArray0[3] = '(';
charArray0[4] = ')';
charArray0[5] = 'i';
charArray0[6] = '\"';
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
TextBuffer textBuffer0 = iOContext1.constructTextBuffer();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertNotNull(textBuffer0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(0, textBuffer0.size());
assertTrue(textBuffer0.hasTextAsCharacters());
assertEquals(0, textBuffer0.getTextOffset());
assertEquals(0, textBuffer0.getCurrentSegmentSize());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, '(', stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
StringReader stringReader1 = new StringReader("Leading zeroes not allowed");
assertFalse(stringReader1.equals((Object)stringReader0));
assertNotNull(stringReader1);
IOContext iOContext2 = new IOContext(bufferRecycler0, stringReader1, false);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertNotNull(iOContext2);
assertFalse(iOContext2.isResourceManaged());
assertNull(iOContext2.getEncoding());
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(jsonEncoding1.equals((Object)jsonEncoding0));
assertFalse(iOContext3.equals((Object)iOContext1));
assertFalse(iOContext3.equals((Object)iOContext0));
assertNotNull(iOContext3);
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertEquals(JsonEncoding.UTF32_LE, iOContext3.getEncoding());
assertFalse(iOContext3.isResourceManaged());
assertNotSame(stringReader1, stringReader0);
assertNotSame(iOContext2, iOContext1);
assertSame(iOContext2, iOContext3);
assertNotSame(iOContext2, iOContext0);
assertNotSame(jsonEncoding1, jsonEncoding0);
assertSame(iOContext3, iOContext2);
assertNotSame(iOContext3, iOContext1);
assertNotSame(iOContext3, iOContext0);
char[] charArray1 = new char[8];
assertFalse(charArray1.equals((Object)charArray0));
charArray1[0] = 'm';
long long0 = readerBasedJsonParser0._nameStartOffset;
assertEquals(0L, long0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 217, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(stringReader1.equals((Object)stringReader0));
assertFalse(iOContext2.equals((Object)iOContext1));
assertFalse(iOContext2.equals((Object)iOContext0));
assertFalse(readerBasedJsonParser1.equals((Object)readerBasedJsonParser0));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser1);
assertFalse(iOContext2.isResourceManaged());
assertEquals(JsonEncoding.UTF32_LE, iOContext2.getEncoding());
assertFalse(readerBasedJsonParser1.canReadTypeId());
assertFalse(readerBasedJsonParser1.canReadObjectId());
assertEquals(0, readerBasedJsonParser1.getFormatFeatures());
assertFalse(readerBasedJsonParser1.requiresCustomCodec());
assertNull(readerBasedJsonParser1.getLastClearedToken());
assertFalse(readerBasedJsonParser1.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser1.getTokenColumnNr());
assertEquals(217, readerBasedJsonParser1.getFeatureMask());
assertEquals(0L, readerBasedJsonParser1.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser1.isClosed());
assertFalse(readerBasedJsonParser1.isExpectedStartArrayToken());
assertEquals(0, readerBasedJsonParser1.getCurrentTokenId());
assertNull(readerBasedJsonParser1.getCurrentToken());
assertFalse(readerBasedJsonParser1.hasTextCharacters());
assertNull(readerBasedJsonParser1.getCurrentName());
assertEquals(1, readerBasedJsonParser1.getTokenLineNr());
assertFalse(readerBasedJsonParser1.hasCurrentToken());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
String string0 = readerBasedJsonParser0.getText();
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(iOContext0.equals((Object)iOContext2));
assertFalse(iOContext0.equals((Object)iOContext3));
assertFalse(stringReader0.equals((Object)stringReader1));
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(readerBasedJsonParser0.equals((Object)readerBasedJsonParser1));
assertNull(string0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(40, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNotSame(iOContext0, iOContext2);
assertNotSame(iOContext0, iOContext3);
assertSame(iOContext0, iOContext1);
assertNotSame(stringReader0, stringReader1);
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(readerBasedJsonParser0, readerBasedJsonParser1);
// try {
readerBasedJsonParser1._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.io.StringReader@0000000303; line: 1, column: 53]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test513() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "xAU";
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-5341), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-5341), (-4699), false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(readerBasedJsonParser0);
assertNull(iOContext0.getEncoding());
assertFalse(iOContext0.isResourceManaged());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer0.size());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertEquals((-5341), readerBasedJsonParser0.getFeatureMask());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
String string1 = "";
// Undeclared exception!
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test514() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(bufferRecycler0);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext0);
assertTrue(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertNotNull(iOContext1);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertTrue(iOContext1.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext1.getEncoding());
assertSame(iOContext0, iOContext1);
assertSame(iOContext1, iOContext0);
StringReader stringReader0 = new StringReader("4B)");
assertNotNull(stringReader0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.size());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 43, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, 0, false);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertNotNull(readerBasedJsonParser0);
assertTrue(iOContext0.isResourceManaged());
assertEquals(JsonEncoding.UTF32_BE, iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertFalse(readerBasedJsonParser0.isClosed());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertEquals(43, readerBasedJsonParser0.getFeatureMask());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertArrayEquals(new char[] {}, charArray0);
assertEquals(0, charArray0.length);
JsonToken jsonToken0 = JsonToken.VALUE_FALSE;
assertEquals(JsonToken.VALUE_FALSE, jsonToken0);
assertTrue(jsonToken0.isBoolean());
assertFalse(jsonToken0.isStructEnd());
assertFalse(jsonToken0.isNumeric());
assertEquals(10, jsonToken0.id());
assertFalse(jsonToken0.isStructStart());
assertEquals("false", jsonToken0.asString());
assertTrue(jsonToken0.isScalarValue());
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test515() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(bufferRecycler0);
String string0 = "";
IOContext iOContext0 = new IOContext(bufferRecycler0, "", false);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(iOContext0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
byte[] byteArray0 = iOContext0.allocWriteEncodingBuffer(3);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertNotNull(byteArray0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(8000, byteArray0.length);
StringReader stringReader0 = new StringReader("com.fasterxml.jackson.core.util.TextBuffer");
assertNotNull(stringReader0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertNotNull(charsToNameCanonicalizer0);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(charsToNameCanonicalizer1);
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertNotSame(charsToNameCanonicalizer0, charsToNameCanonicalizer1);
assertNotSame(charsToNameCanonicalizer1, charsToNameCanonicalizer0);
char[] charArray0 = new char[5];
charArray0[0] = '\"';
charArray0[1] = 'A';
charArray0[2] = 'x';
charArray0[3] = '5';
charArray0[4] = '|';
boolean boolean0 = true;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, 0, true);
assertEquals(0, BufferRecycler.CHAR_TOKEN_BUFFER);
assertEquals(3, BufferRecycler.BYTE_BASE64_CODEC_BUFFER);
assertEquals(2, BufferRecycler.CHAR_TEXT_BUFFER);
assertEquals(2, BufferRecycler.BYTE_WRITE_CONCAT_BUFFER);
assertEquals(3, BufferRecycler.CHAR_NAME_COPY_BUFFER);
assertEquals(1, BufferRecycler.BYTE_WRITE_ENCODING_BUFFER);
assertEquals(1, BufferRecycler.CHAR_CONCAT_BUFFER);
assertEquals(0, BufferRecycler.BYTE_READ_IO_BUFFER);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertEquals(33, CharsToNameCanonicalizer.HASH_MULT);
assertFalse(charsToNameCanonicalizer0.equals((Object)charsToNameCanonicalizer1));
assertFalse(charsToNameCanonicalizer1.equals((Object)charsToNameCanonicalizer0));
assertNotNull(readerBasedJsonParser0);
assertFalse(iOContext0.isResourceManaged());
assertNull(iOContext0.getEncoding());
assertEquals(0, charsToNameCanonicalizer0.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer0.collisionCount());
assertEquals(839877741, charsToNameCanonicalizer0.hashSeed());
assertEquals(64, charsToNameCanonicalizer0.bucketCount());
assertEquals(0, charsToNameCanonicalizer0.size());
assertFalse(charsToNameCanonicalizer0.maybeDirty());
assertEquals(0, charsToNameCanonicalizer1.collisionCount());
assertEquals(64, charsToNameCanonicalizer1.bucketCount());
assertEquals(0, charsToNameCanonicalizer1.maxCollisionLength());
assertEquals(0, charsToNameCanonicalizer1.size());
assertFalse(charsToNameCanonicalizer1.maybeDirty());
assertEquals(839877741, charsToNameCanonicalizer1.hashSeed());
assertEquals(1, readerBasedJsonParser0.getTokenColumnNr());
assertFalse(readerBasedJsonParser0.hasCurrentToken());
assertEquals(0L, readerBasedJsonParser0.getTokenCharacterOffset());
assertFalse(readerBasedJsonParser0.hasTextCharacters());
assertFalse(readerBasedJsonParser0.canReadObjectId());
assertFalse(readerBasedJsonParser0.isExpectedStartArrayToken());
assertEquals(1, readerBasedJsonParser0.getTokenLineNr());
assertFalse(readerBasedJsonParser0.isExpectedStartObjectToken());
assertNull(readerBasedJsonParser0.getCurrentName());
assertFalse(readerBasedJsonParser0.isClosed());
assertNull(readerBasedJsonParser0.getCurrentToken());
assertEquals(0, readerBasedJsonParser0.getCurrentTokenId());
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
assertFalse(readerBasedJsonParser0.requiresCustomCodec());
assertEquals(3, readerBasedJsonParser0.getFeatureMask());
assertNull(readerBasedJsonParser0.getLastClearedToken());
assertFalse(readerBasedJsonParser0.canReadTypeId());
assertArrayEquals(new char[] {'\"', 'A', 'x', '5', '|'}, charArray0);
assertEquals(5, charArray0.length);
// try {
readerBasedJsonParser0._skipString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000304; line: 1, column: 45]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test516() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("xv>ZM?c6v");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[5];
charArray0[0] = 't';
charArray0[1] = '(';
charArray0[2] = '*';
charArray0[3] = ':';
charArray0[4] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 2, 0, true);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000305; line: 1, column: 14]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test517() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("i;]7[xe}qg)h");
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
StringReader stringReader1 = new StringReader("+Infinity");
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader2 = new StringReader("+Infinity");
char[] charArray0 = new char[1];
charArray0[0] = '';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2174), stringReader2, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, 1, true);
readerBasedJsonParser0.nextBooleanValue();
int int0 = readerBasedJsonParser0.getTextLength();
assertArrayEquals(new char[] {'y'}, charArray0);
assertEquals(9, int0);
}
@Test(timeout = 4000)
public void test518() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(98);
char[] charArray0 = new char[1];
charArray0[0] = 'K';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 544, 33, true);
int int0 = readerBasedJsonParser0.getTextLength();
assertEquals(0, int0);
}
@Test(timeout = 4000)
public void test519() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("4B8)");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
char[] charArray0 = new char[6];
charArray0[0] = 'b';
charArray0[1] = 'Y';
charArray0[2] = 'b';
charArray0[3] = 'b';
charArray0[4] = 'Y';
charArray0[5] = 'b';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1, (-241), false);
JsonToken jsonToken0 = JsonToken.VALUE_NULL;
readerBasedJsonParser0.getValueAsString();
readerBasedJsonParser0.getTextLength();
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000306; line: 1, column: -230]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test520() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("4B)");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(4);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-1591), (-1591), true);
// Undeclared exception!
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// }
}
@Test(timeout = 4000)
public void test521() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
FileSystemHandling.shouldThrowIOException((EvoSuiteFile) null);
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
iOContext0.allocBase64Buffer();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 59, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser0._skipCR();
// try {
readerBasedJsonParser0._reportInvalidToken("84)$D6Sz$5thle", "FIELD_NAME");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '84)$D6Sz$5thle9XU': was expecting FIELD_NAME
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000307; line: 2, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test522() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("Vbwi40]n");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
char[] charArray0 = new char[8];
charArray0[0] = 'L';
charArray0[1] = '5';
charArray0[2] = '`';
charArray0[3] = 'v';
charArray0[4] = 'p';
charArray0[5] = 'q';
charArray0[6] = 'F';
charArray0[7] = 'R';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 2, (-483), false);
// try {
readerBasedJsonParser0._reportInvalidToken("", ": was expecting closing '");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'Vbwi40': was expecting : was expecting closing '
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000308; line: 1, column: -476]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test523() throws Throwable {
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("9XU{:w5+<ELw");
char[] charArray0 = new char[5];
stringReader0.read(charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'w5': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000309; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test524() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
StringReader stringReader0 = new StringReader("'QWnqca4=");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[7];
charArray0[0] = 'T';
charArray0[1] = ':';
charArray0[2] = '6';
charArray0[3] = '$';
charArray0[4] = 'L';
charArray0[5] = 'o';
charArray0[6] = 'p';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 48, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 0, 3, false);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'T': was expecting ('true', 'false' or 'null')
// // at [Source: java.lang.String@0000000310; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test525() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = mock(IOContext.class, new ViolatedAssumptionAnswer());
doReturn((TextBuffer) null).when(iOContext0).constructTextBuffer();
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((Object) null).when(objectCodec0).readValue(any(com.fasterxml.jackson.core.JsonParser.class) , any(com.fasterxml.jackson.core.type.TypeReference.class));
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[9];
charArray0[0] = 'E';
charArray0[1] = '|';
charArray0[2] = 'L';
charArray0[3] = '';
charArray0[4] = '*';
charArray0[5] = ';';
charArray0[6] = 'H';
charArray0[7] = 'y';
charArray0[8] = ',';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 338, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 44, 0, true);
TypeReference<Object> typeReference0 = (TypeReference<Object>) mock(TypeReference.class, new ViolatedAssumptionAnswer());
readerBasedJsonParser0.readValueAs((TypeReference<?>) typeReference0);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext2 = iOContext1.withEncoding(jsonEncoding0);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext2, 117, stringReader0, objectCodec1, charsToNameCanonicalizer0);
boolean boolean0 = readerBasedJsonParser1.loadMore();
assertFalse(boolean0);
}
@Test(timeout = 4000)
public void test526() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(125);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
ObjectCodec objectCodec1 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
readerBasedJsonParser0.setCodec(objectCodec1);
assertEquals(0, readerBasedJsonParser0.getFormatFeatures());
}
@Test(timeout = 4000)
public void test527() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = true;
String string0 = "epTUjDM@L8";
StringReader stringReader0 = new StringReader("epTUjDM@L8");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[5];
charArray0[0] = 'h';
charsToNameCanonicalizer0.release();
charArray0[3] = 'M';
stringReader0.read(charArray0);
Integer integer0 = new Integer(91);
IOContext iOContext0 = new IOContext(bufferRecycler0, integer0, true);
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 0, 3, true);
readerBasedJsonParser0.setCodec((ObjectCodec) null);
// try {
readerBasedJsonParser0._parsePosNumber(5);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('p' (code 112)) in numeric value: Exponent indicator not followed by a digit
// // at [Source: java.lang.Integer@0000000311; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test528() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("x)u]v:mt /");
stringReader0.skip(2);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
StringReader stringReader1 = new StringReader("x)u]v:mt /");
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2502, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 418, true);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextLongValue(2);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // 3
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test529() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
char[] charArray0 = new char[0];
stringReader0.read(charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
char[] charArray1 = new char[1];
charArray1[0] = '/';
charsToNameCanonicalizer1.release();
IOContext iOContext1 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('X' (code 88)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000312; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test530() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char char0 = 'L';
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[1] = '$';
charArray0[2] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 3, false);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 91, false);
// Undeclared exception!
// try {
readerBasedJsonParser1.nextFieldName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test531() throws Throwable {
IOContext iOContext0 = new IOContext((BufferRecycler) null, (Object) null, false);
int int0 = (-1222);
String string0 = "Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow";
StringReader stringReader0 = new StringReader("Non-standard token 'Infinity': enable JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS to allow");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[7];
charArray0[0] = 'm';
charArray0[1] = 'p';
charArray0[2] = '9';
charArray0[3] = ',';
charArray0[4] = '$';
charArray0[5] = 'i';
charArray0[6] = '7';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-1222), stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, (-2), 0, false);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextLongValue((-1222));
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -2
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test532() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("Current token (");
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding1);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
StringReader stringReader1 = new StringReader("Current token (");
charsToNameCanonicalizer0.makeChild(58);
char[] charArray0 = new char[7];
charArray0[0] = '\"';
charArray0[1] = '\"';
charArray0[2] = '\"';
charArray0[3] = '\"';
charArray0[4] = '\"';
charArray0[5] = '\"';
charArray0[6] = '\"';
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(33);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
// try {
readerBasedJsonParser0._finishString();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000313; line: 1, column: 31]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test533() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF8;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[7];
charArray0[0] = '{';
charArray0[1] = '.';
charArray0[2] = 'j';
charArray0[3] = '|';
JsonEncoding jsonEncoding1 = JsonEncoding.UTF16_LE;
iOContext0.setEncoding(jsonEncoding1);
charArray0[4] = '0';
charArray0[5] = 'd';
charArray0[6] = '|';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, (Reader) null, objectCodec0, charsToNameCanonicalizer0, charArray0, 1, 3, false);
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: UNKNOWN; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test534() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("}_liH$?B:");
CharsToNameCanonicalizer.createRoot();
stringReader0.close();
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader1 = new StringReader("");
SerializedString serializedString0 = new SerializedString("/sfMq[*<s|U-JOx");
IOContext iOContext0 = new IOContext(bufferRecycler0, stringReader1, false);
ByteBuffer byteBuffer0 = ByteBuffer.allocate(2598);
serializedString0.putUnquotedUTF8(byteBuffer0);
char[] charArray0 = new char[5];
charArray0[3] = '/';
charArray0[2] = '/';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 3, true);
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test535() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("f!9.!!>Eo{B*=uk!~fq");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 13, 0, true);
SerializedString serializedString0 = new SerializedString("");
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test536() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "2l:bgu~bKhm?zu/F", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("2l:bgu~bKhm?zu/F");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 51, 2, true);
SerializedString serializedString0 = new SerializedString("2l:bgu~bKhm?zu/F");
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName((SerializableString) serializedString0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test537() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0);
// Undeclared exception!
// try {
readerBasedJsonParser0._parsePosNumber(0);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test538() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
String string0 = "Zpt}'rrB8x!sm)Nfx";
StringReader stringReader0 = new StringReader("Zpt}'rrB8x!sm)Nfx");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, objectCodec0, charsToNameCanonicalizer0, (char[]) null, 2154, 0, false);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("Zpt}'rrB8x!sm)Nfx", 3);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test539() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[1] = '$';
charArray0[2] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 3, false);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 200, 91, false);
// try {
readerBasedJsonParser1._matchToken("L%zu=\"`?&: ap", 1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'LL': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000314; line: 1, column: 93]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test540() throws Throwable {
boolean boolean0 = false;
StringReader stringReader0 = new StringReader("+rbIEj6j$$\"0#RMTPTO");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
ObjectCodec objectCodec0 = null;
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "+rbIEj6j$$\"0#RMTPTO", false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
iOContext0.withEncoding(jsonEncoding0);
int int0 = 110;
byte[] byteArray0 = new byte[1];
char[] charArray0 = new char[7];
charArray0[0] = '&';
charArray0[1] = '@';
charArray0[2] = '*';
charArray0[3] = 'Y';
charArray0[4] = '1';
charArray0[5] = 'o';
charArray0[6] = 'U';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 116, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 561, (-2433), true);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken((String) null, 57);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test541() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[8];
charArray0[0] = 'I';
charArray0[1] = '.';
charArray0[2] = 'I';
charArray0[3] = 'I';
charArray0[4] = 'T';
charArray0[5] = '.';
charArray0[6] = '.';
charArray0[7] = 'O';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-1831), stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 3, 95, false);
readerBasedJsonParser0.getCodec();
// try {
readerBasedJsonParser0.nextLongValue((-1191L));
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'IT': was expecting 'null', 'true', 'false' or NaN
// // at [Source: UNKNOWN; line: 1, column: 6]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test542() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild((-578));
charsToNameCanonicalizer0.release();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, 2, 3, false);
// Undeclared exception!
// try {
readerBasedJsonParser0._matchToken("+", 117);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test543() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
FileSystemHandling.shouldAllThrowIOExceptions();
StringReader stringReader0 = new StringReader("Lho");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader1 = new StringReader("");
CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[9];
charArray0[0] = 'z';
charArray0[1] = 'L';
charArray0[2] = 'U';
charArray0[3] = 'z';
charArray0[4] = '>';
charArray0[5] = '>';
charArray0[6] = 'G';
charArray0[7] = 'D';
charArray0[8] = '>';
stringReader0.read(charArray0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 69, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.nextTextValue();
readerBasedJsonParser0.getTokenLocation();
JsonToken jsonToken0 = JsonToken.VALUE_NUMBER_INT;
readerBasedJsonParser0._getText2(jsonToken0);
assertTrue(readerBasedJsonParser0.isClosed());
}
@Test(timeout = 4000)
public void test544() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
StringReader stringReader0 = new StringReader("Null String illegal for SerializedString");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
JsonToken jsonToken0 = JsonToken.START_ARRAY;
String string0 = readerBasedJsonParser0._getText2(jsonToken0);
assertEquals("[", string0);
}
@Test(timeout = 4000)
public void test545() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[7];
charArray0[0] = ':';
charArray0[1] = '\"';
charArray0[2] = ':';
charArray0[3] = '\"';
charArray0[4] = '=';
charArray0[5] = '\"';
charArray0[6] = '\"';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-30), 0, false);
JsonToken jsonToken0 = JsonToken.END_OBJECT;
readerBasedJsonParser0._getText2(jsonToken0);
// Undeclared exception!
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -30
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test546() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
IOContext iOContext1 = new IOContext(bufferRecycler0, iOContext0, true);
boolean boolean0 = false;
BufferRecycler bufferRecycler1 = new BufferRecycler();
Reader reader0 = null;
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = null;
// try {
readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, (Reader) null, (ObjectCodec) null, (CharsToNameCanonicalizer) null);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test547() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
String string0 = "uENjZQW&";
StringReader stringReader0 = new StringReader("uENjZQW&");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
char[] charArray0 = new char[5];
charArray0[0] = '5';
charArray0[1] = '\"';
charArray0[2] = '9';
charArray0[3] = 'u';
charArray0[4] = 'e';
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 52, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2692, (-1422), true);
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('N' (code 78)): expected a hex-digit for character escape sequence
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000315; line: 1, column: 4]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test548() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-5341), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-5341), (-4699), false);
readerBasedJsonParser0.getTextOffset();
StringReader stringReader0 = new StringReader("LbvIhLO{YTZL_>0 \"");
readerBasedJsonParser0._reader = (Reader) stringReader0;
// try {
readerBasedJsonParser0._handleOddName(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 3)): was expecting double-quote to start field name
// // at [Source: java.lang.String@0000000316; line: 1, column: -5340]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test549() throws Throwable {
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
String string0 = "9\\XU\\{:<ELw";
StringReader stringReader0 = new StringReader("9XU{:<ELw");
char[] charArray0 = new char[5];
stringReader0.read(charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextLongValue(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('<' (code 60)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.sym.CharsToNameCanonicalizer@0000000317; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test550() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("YecxeP9Y&vrKkae@n=");
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 594, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
char[] charArray0 = iOContext0.allocNameCopyBuffer(101);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
boolean boolean0 = false;
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1238, 3, false);
// try {
readerBasedJsonParser1._handleApos();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000318; line: 1, column: 40]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test551() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
char[] charArray0 = new char[0];
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(0);
char[] charArray1 = new char[1];
charArray1[0] = '/';
charsToNameCanonicalizer1.release();
IOContext iOContext0 = new IOContext(bufferRecycler0, charsToNameCanonicalizer0, true);
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
StringReader stringReader0 = new StringReader("\"y>v4gYg'deLU");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 500, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 1094, 2, true);
readerBasedJsonParser0.getCodec();
// Undeclared exception!
// try {
readerBasedJsonParser0._reportInvalidToken((String) null, "): only regular white space (\r, \n, \t) is allowed between tokens");
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// }
}
@Test(timeout = 4000)
public void test552() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
doReturn((String) null).when(objectCodec0).toString();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
charsToNameCanonicalizer0.release();
CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, (-2613), stringReader0, objectCodec0, charsToNameCanonicalizer1, (char[]) null, (-805), 3, true);
readerBasedJsonParser0.getCodec();
readerBasedJsonParser0.getTextOffset();
// Undeclared exception!
// try {
readerBasedJsonParser0._decodeEscaped();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test553() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext1 = new IOContext(bufferRecycler1, "expected a digit for number exponent", false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("expected a digit for number exponent");
char[] charArray0 = new char[6];
charArray0[0] = 'L';
charArray0[1] = 'L';
charArray0[2] = 'L';
charArray0[3] = 'L';
charArray0[4] = 'L';
charArray0[5] = 'L';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2603, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 102, 2, false);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'expected': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000319; line: 1, column: 11]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test554() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("*s");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(1);
char[] charArray0 = new char[9];
charArray0[0] = 'v';
charArray0[1] = 'c';
charArray0[2] = '$';
charArray0[3] = 'q';
charArray0[4] = '!';
charArray0[5] = 'I';
charArray0[6] = 'a';
charArray0[7] = '\\';
charArray0[8] = '8';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1655, stringReader0, objectCodec0, charsToNameCanonicalizer1, charArray0, 3, (-533), true);
// try {
readerBasedJsonParser0._reportInvalidToken("");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '': was expecting 'null', 'true', 'false' or NaN
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000320; line: 1, column: -532]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test555() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
char[] charArray0 = new char[5];
stringReader0.read(charArray0);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(39, "9XU{:<ELw");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character (''' (code 39)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000321; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test556() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler1, fileSystemHandling0, true);
StringReader stringReader0 = new StringReader("9XU{:<ELw");
char[] charArray0 = new char[1];
stringReader0.read(charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
IOContext iOContext1 = new IOContext(bufferRecycler0, bufferRecycler0, true);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser0.getCurrentName();
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(343, "9XU{:<ELw");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('\u0157' (code 343 / 0x157)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000322; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test557() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("4)O24;p]f4ocT<<");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 4000, stringReader0, objectCodec0, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._isNextTokenNameMaybe(0, "*gDe");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 0)): was expecting double-quote to start field name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000323; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test558() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, (Object) null, true);
StringReader stringReader0 = new StringReader("'");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
String string0 = readerBasedJsonParser0.getValueAsString("'");
assertNotNull(string0);
assertEquals("'", string0);
}
@Test(timeout = 4000)
public void test559() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("bp1D)FnoSg-7cIs%su~");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1);
readerBasedJsonParser0.loadMore();
stringReader0.markSupported();
stringReader0.skip(1);
byte[] byteArray0 = new byte[2];
byteArray0[0] = (byte)49;
byteArray0[1] = (byte)0;
// Undeclared exception!
// try {
iOContext0.releaseBase64Buffer(byteArray0);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test560() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
StringReader stringReader0 = new StringReader("L#aV|xlTY^aV");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
stringReader0.close();
FileSystemHandling.setPermissions((EvoSuiteFile) null, false, false, false);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Stream closed
// //
// verifyException("java.io.StringReader", e);
// }
}
@Test(timeout = 4000)
public void test561() throws Throwable {
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
FileSystemHandling.shouldAllThrowIOExceptions();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader0 = new StringReader("false");
CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 57, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.nextBooleanValue();
assertEquals(10, readerBasedJsonParser0.getCurrentTokenId());
}
@Test(timeout = 4000)
public void test562() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
byte[] byteArray0 = new byte[5];
byteArray0[0] = (byte)50;
byteArray0[1] = (byte)91;
byteArray0[2] = (byte) (-54);
byteArray0[3] = (byte) (-66);
byteArray0[4] = (byte)56;
FileSystemHandling.appendDataToFile((EvoSuiteFile) null, byteArray0);
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 1, false);
// try {
readerBasedJsonParser0.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test563() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
boolean boolean0 = false;
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
int int0 = 224;
String string0 = "";
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharBuffer charBuffer0 = CharBuffer.allocate(3);
stringReader0.read(charBuffer0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[0];
int int1 = 1788;
charsToNameCanonicalizer0.release();
stringReader0.markSupported();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 224, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 1788, 1, false);
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test564() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
BufferRecycler bufferRecycler1 = new BufferRecycler();
BufferRecycler bufferRecycler2 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
char[] charArray0 = new char[4];
charArray0[0] = '$';
charArray0[1] = '$';
charArray0[2] = 'L';
charArray0[3] = 'D';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 9, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, (-1148), false);
Object object0 = readerBasedJsonParser0.getInputSource();
IOContext iOContext2 = new IOContext(bufferRecycler2, object0, false);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF32_BE;
IOContext iOContext3 = iOContext2.withEncoding(jsonEncoding1);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext3, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, (-1167), 2, true);
readerBasedJsonParser0.nextFieldName();
// try {
readerBasedJsonParser0._handleOddValue(1);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 1)): expected a valid value (number, String, array, object, 'true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000324; line: 1, column: -1145]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test565() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("4B)");
StringReader stringReader1 = new StringReader("-Infinity");
CharsToNameCanonicalizer.createRoot();
StringReader stringReader2 = new StringReader("_&x16 cUXB*Z");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[6];
charArray0[0] = '<';
charArray0[1] = 'U';
charArray0[2] = '>';
charArray0[3] = '`';
charArray0[4] = 'D';
charArray0[5] = 'z';
stringReader2.read(charArray0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing ''' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000325; line: 1, column: 15]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test566() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
StringReader stringReader0 = new StringReader("'QWnqca4=");
StringReader stringReader1 = new StringReader("");
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader2 = new StringReader("'QWnqca4=");
StringReader stringReader3 = new StringReader("was expecting a colon to separate field name and value");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2137, stringReader2, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: java.lang.String@0000000326; line: 1, column: 19]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test567() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("4B)");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(4);
char[] charArray0 = new char[0];
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 43, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 93, 0, false);
// try {
readerBasedJsonParser0._parsePosNumber(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 0
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test568() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("4B)");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[0];
IOContext iOContext0 = new IOContext(bufferRecycler0, "4B)", false);
StringReader stringReader1 = new StringReader("");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 93, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1874, 1216, false);
readerBasedJsonParser0._releaseBuffers();
// try {
readerBasedJsonParser0._parseAposName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Reader returned 0 characters when trying to read 1216
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test569() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF16_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
iOContext0.allocWriteEncodingBuffer(3);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(308);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, objectCodec0, charsToNameCanonicalizer1);
readerBasedJsonParser0._closeInput();
readerBasedJsonParser0._nameStartCol = 0;
// try {
readerBasedJsonParser0._parseName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing '\"' for name
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000327; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test570() throws Throwable {
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
FileSystemHandling.shouldAllThrowIOExceptions();
BufferRecycler bufferRecycler0 = new BufferRecycler();
FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
String string0 = "9\\XU\\{:<ELw";
StringReader stringReader0 = new StringReader("9XU{:<ELw");
char[] charArray0 = new char[5];
stringReader0.read(charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
StringReader stringReader1 = new StringReader("^c+H");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 1296, 52, true);
readerBasedJsonParser0.getText();
// Undeclared exception!
// try {
readerBasedJsonParser0._releaseBuffers();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test571() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "", true);
StringReader stringReader0 = new StringReader("'QWnqca4=");
StringReader stringReader1 = new StringReader("");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
StringReader stringReader2 = new StringReader("'QWnqca4=");
StringReader stringReader3 = new StringReader("was expecting a colon to separate field name and value");
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 33, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
readerBasedJsonParser0.nextTextValue();
readerBasedJsonParser0._releaseBuffers();
assertTrue(readerBasedJsonParser0.isClosed());
}
@Test(timeout = 4000)
public void test572() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
iOContext0.allocWriteEncodingBuffer(1);
IOContext iOContext1 = new IOContext(bufferRecycler0, "com.fasterxml.jackson.core.util.TextBuffer", true);
StringReader stringReader0 = new StringReader("");
char[] charArray0 = new char[7];
charArray0[0] = 'T';
charArray0[1] = '9';
charArray0[2] = '\\';
charArray0[3] = '(';
charArray0[4] = 'D';
charArray0[5] = '7';
charArray0[6] = 'b';
stringReader0.read(charArray0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild((-1));
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
charsToNameCanonicalizer1.release();
IOContext iOContext2 = new IOContext(bufferRecycler0, "", true);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1);
readerBasedJsonParser0.nextLongValue((-1L));
// try {
readerBasedJsonParser0._finishString2();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-input: was expecting closing quote for a string value
// // at [Source: java.lang.String@0000000328; line: 1, column: 1]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test573() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[9];
charArray0[0] = 'e';
charArray0[1] = '8';
charArray0[2] = 'G';
charArray0[3] = 'L';
charArray0[4] = '1';
charArray0[5] = '{';
charArray0[6] = 'Q';
charArray0[7] = 'e';
charArray0[8] = '3';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer0, charArray0, 33, 33, true);
// Undeclared exception!
// try {
readerBasedJsonParser0._releaseBuffers();
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.io.IOContext", e);
// }
}
@Test(timeout = 4000)
public void test574() throws Throwable {
StringReader stringReader0 = new StringReader("Leading zeroes not allowed");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
Object object0 = new Object();
CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer.createRoot();
StringReader stringReader1 = new StringReader("8GPS&");
stringReader0.skip((-2147483648L));
CharsToNameCanonicalizer.createRoot();
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "Leading zeroes not allowed", true);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 8, stringReader1, (ObjectCodec) null, charsToNameCanonicalizer0);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('G' (code 71)): Expected space separating root-level values
// // at [Source: java.lang.String@0000000329; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test575() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("F");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
charsToNameCanonicalizer0.makeChild(3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
FileSystemHandling.setPermissions((EvoSuiteFile) null, true, true, true);
readerBasedJsonParser0.getValueAsString("'QWnqca4=");
// try {
readerBasedJsonParser0.nextBooleanValue();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'F': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000330; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test576() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("4B)");
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[7];
charArray0[0] = '8';
charArray0[1] = '!';
charArray0[2] = '8';
charArray0[4] = '8';
charArray0[5] = 'a';
charArray0[6] = '\\';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 1, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 2, 7, true);
// try {
readerBasedJsonParser0._reportInvalidToken("4B)");
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token '4B)8\u00008a': was expecting 'null', 'true', 'false' or NaN
// // at [Source: UNKNOWN; line: 1, column: 7]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test577() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("Current token (");
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
stringReader0.markSupported();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(3);
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 0, stringReader0, objectCodec0, charsToNameCanonicalizer1);
iOContext0.allocNameCopyBuffer(0);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'Current': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000331; line: 1, column: 8]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test578() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("L%zu=\"`?&: ap");
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
BufferRecycler bufferRecycler1 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler1, bufferRecycler1, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_BE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer1 = CharsToNameCanonicalizer.createRoot();
char[] charArray0 = new char[3];
charArray0[0] = 'L';
charArray0[1] = '$';
charArray0[2] = '$';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 2, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer1, charArray0, 3, 3, false);
ReaderBasedJsonParser readerBasedJsonParser1 = new ReaderBasedJsonParser(iOContext1, 0, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, 200, 91, false);
// try {
readerBasedJsonParser1.nextFieldName();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unrecognized token 'L': was expecting ('true', 'false' or 'null')
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000332; line: 1, column: 93]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test579() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 2, (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, 2, (-4699), false);
readerBasedJsonParser0.getValueAsString();
// try {
readerBasedJsonParser0._parsePosNumber(39);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected end-of-inputNo digit following minus sign
// // at [Source: java.lang.String@0000000333; line: 1, column: -4697]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test580() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
StringReader stringReader0 = new StringReader("No digit following minus sign");
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext0 = new IOContext(bufferRecycler0, " ,'76}h", true);
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
JsonEncoding jsonEncoding1 = JsonEncoding.UTF8;
iOContext1.withEncoding(jsonEncoding1);
iOContext0.setEncoding(jsonEncoding0);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
FileSystemHandling fileSystemHandling0 = new FileSystemHandling();
char[] charArray0 = new char[4];
charArray0[0] = '(';
charArray0[1] = '(';
charArray0[2] = '_';
charArray0[3] = '_';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 1001, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0, charArray0, (-5), 2, true);
// Undeclared exception!
// try {
readerBasedJsonParser0._parsePosNumber(48);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -6
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test581() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-5341), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-5341), (-4699), false);
readerBasedJsonParser0.getValueAsString();
// Undeclared exception!
// try {
readerBasedJsonParser0._parsePosNumber(39);
// fail("Expecting exception: NullPointerException");
// } catch(NullPointerException e) {
// //
// // no message in exception (getMessage() returned null)
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test582() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
String string0 = "xAU";
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
ObjectCodec objectCodec0 = null;
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-472), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0);
// Undeclared exception!
// try {
readerBasedJsonParser0._parsePosNumber(102);
// fail("Expecting exception: ArrayIndexOutOfBoundsException");
// } catch(ArrayIndexOutOfBoundsException e) {
// //
// // -1
// //
// verifyException("com.fasterxml.jackson.core.json.ReaderBasedJsonParser", e);
// }
}
@Test(timeout = 4000)
public void test583() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, "xAU", false);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, (-5341), (Reader) null, (ObjectCodec) null, charsToNameCanonicalizer0, (char[]) null, (-5341), (-4699), false);
// try {
readerBasedJsonParser0._handleOddName(3);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ((CTRL-CHAR, code 3)): was expecting double-quote to start field name
// // at [Source: java.lang.String@0000000334; line: 1, column: -5340]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test584() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, false);
JsonEncoding jsonEncoding0 = JsonEncoding.UTF32_LE;
IOContext iOContext1 = iOContext0.withEncoding(jsonEncoding0);
ObjectCodec objectCodec0 = mock(ObjectCodec.class, new ViolatedAssumptionAnswer());
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
CharsToNameCanonicalizer charsToNameCanonicalizer1 = charsToNameCanonicalizer0.makeChild(2);
char[] charArray0 = new char[5];
charArray0[0] = 'b';
charArray0[1] = 'Y';
charArray0[2] = ':';
charArray0[3] = '#';
charArray0[4] = '@';
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext1, 0, (Reader) null, objectCodec0, charsToNameCanonicalizer1, charArray0, 0, 1, false);
// try {
readerBasedJsonParser0._parsePosNumber(0);
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('b' (code 98)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000335; line: 1, column: 2]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
@Test(timeout = 4000)
public void test585() throws Throwable {
BufferRecycler bufferRecycler0 = new BufferRecycler();
IOContext iOContext0 = new IOContext(bufferRecycler0, bufferRecycler0, true);
StringReader stringReader0 = new StringReader("4B)");
IOContext iOContext1 = new IOContext(bufferRecycler0, (Object) null, true);
CharsToNameCanonicalizer charsToNameCanonicalizer0 = CharsToNameCanonicalizer.createRoot();
ObjectCodec objectCodec0 = null;
ReaderBasedJsonParser readerBasedJsonParser0 = new ReaderBasedJsonParser(iOContext0, 3, stringReader0, (ObjectCodec) null, charsToNameCanonicalizer0);
iOContext0.allocNameCopyBuffer(58);
// try {
readerBasedJsonParser0.nextToken();
// fail("Expecting exception: IOException");
// } catch(IOException e) {
// //
// // Unexpected character ('B' (code 66)): Expected space separating root-level values
// // at [Source: com.fasterxml.jackson.core.util.BufferRecycler@0000000001; line: 1, column: 3]
// //
// verifyException("com.fasterxml.jackson.core.JsonParser", e);
// }
}
}
| [
"pouria.derakhshanfar@gmail.com"
] | pouria.derakhshanfar@gmail.com |
54bdb807093828aa1664d521426b640abb94c2ab | 57fa628dcee7c51b7a93c3db141dce5fc34eeb71 | /iris.springframework.recipe/src/main/java/com/example/iris/springframework/repositories/UnitOfMeasureRepository.java | 21612100b3bce4bc24c4b1cc8e27001cb2c10df8 | [] | no_license | IrisIovu/RecipeSpringProject | 78824c03728014f35342d191968497897a4e0d88 | 079773df8d9cf88aff3c718485cb4d9ab455647d | refs/heads/master | 2022-12-07T04:59:56.433700 | 2020-08-27T09:42:45 | 2020-08-27T09:42:45 | 288,937,976 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 266 | java | package com.example.iris.springframework.repositories;
import com.example.iris.springframework.domain.UnitOfMeasure;
import org.springframework.data.repository.CrudRepository;
public interface UnitOfMeasureRepository extends CrudRepository<UnitOfMeasure,Long> {
}
| [
"Ainaaremere1!"
] | Ainaaremere1! |
79a4917512e3968437d5fc2c11c55f1b9bd2e3c8 | 9b1537b868c8b35f6f5a68eaea2e84483c6adcbf | /addressbook-web-tests/src/test/java/ru/stqa/pft/addressbook/tests/DeleteContactFromGroupTests.java | c06d9380ee8ccad0cb6bc5ea1699d983b41dcadf | [
"Apache-2.0"
] | permissive | oleg-grigor/java_pft | 9c9c85853129ab5a940b389eb67521020f6e3102 | 2b5a99b4ff9677ab4a69b5852ed66e191ac6bdd9 | refs/heads/master | 2020-12-29T22:16:24.911637 | 2020-04-14T13:18:34 | 2020-04-14T13:18:34 | 238,751,533 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,064 | java | package ru.stqa.pft.addressbook.tests;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
import ru.stqa.pft.addressbook.model.ContactData;
import ru.stqa.pft.addressbook.model.GroupData;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
public class DeleteContactFromGroupTests extends TestBase {
private ContactData contact;
private GroupData group;
private boolean contactCreated;
private boolean groupCreated;
@BeforeMethod
public void ensurePrecondition() {
if (app.db().contacts().size() == 0) {
app.contact().create(new ContactData().withFirstname("FirstTest1").withLastname("LastTest4").withAddress("AddressTest").
withTelHome("123456789").withTelMobile("1233").withTelWork("34444").withEmail("test@test.com")
.withEmail2("qwe@qwe.com").withEmail3("asd@asd.com"));
contact = app.db().contacts().iterator().next();
contactCreated = true;
}
if (app.db().groups().size() == 0) {
app.goTo().groupPage();
app.group().create(new GroupData().withName("test7").withHeader("test8").withFooter("test9"));
app.goTo().homePage();
group = app.db().groups().iterator().next();
groupCreated = true;
}
if (!(contactCreated && groupCreated)) {
for (ContactData c : app.db().contacts()) {
if (c.getGroups().size() != 0) {
contact = c;
group = c.getGroups().iterator().next();
return;
}
}
}
contact = app.db().contacts().iterator().next();
group = app.db().groups().iterator().next();
app.goTo().homePage();
app.contact().addInSelectedGroup(contact.getId(), group.getName());
}
@Test
public void testDeleteContactFromGroup() {
ContactData contactWithoutGroup = contact.removeOfGroup(group);
app.goTo().homePage();
app.contact().deleteFromSelectedGroup(contact.getId(), group.getName());
assertThat(contact.getGroups(), equalTo(contactWithoutGroup.getGroups().without(group)));
}
}
| [
"ext.oleg.grigorev@tieto.com"
] | ext.oleg.grigorev@tieto.com |
987c38d19b325489e3a12b820b8c861ac7222218 | d7ddb657fd6a5c02434e09b847e30dca5eae521a | /MetaCivTk3/src/civilisation/inspecteur/simulation/environnement/GCarte.java | a0ee800d76865c04e61a9c8bdc4d737de8e35bb7 | [] | no_license | Metasky/Metaciv3 | 1cc88f27a89151e7d701804709667ce9d3e10931 | c081701765b1be840d4fb9a43b16cc09490b57ad | refs/heads/master | 2023-03-01T07:47:00.100620 | 2014-11-03T10:21:18 | 2014-11-03T10:21:18 | 337,462,508 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 7,379 | java | package civilisation.inspecteur.simulation.environnement;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.MouseEvent;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import java.util.SortedSet;
import java.util.Stack;
import javax.swing.ImageIcon;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import civilisation.inspecteur.animations.JJComponent;
import civilisation.inspecteur.animations.JJPanel;
import civilisation.world.Terrain;
import civilisation.*;
/**
* @author juliennigon
*
*/
public class GCarte extends JJComponent{
PanelEnvironnement panelEnvironnement;
BufferedImage bufferedImage; /*buffer to keep the map in memory*/
int espacementVerticalCarte;
int espacementHorizontalCarte;
JPopupMenu popup;
HashMap<Civilisation,PseudoPatch> startingPositions = new HashMap<Civilisation,PseudoPatch>();
public GCarte(JJPanel parent, int espacementVerticalCarte, int espacementHorizontalCarte,PanelEnvironnement panelEnvironnement) {
super(parent, espacementVerticalCarte, espacementHorizontalCarte, panelEnvironnement.getTaillePseudoPatch()*panelEnvironnement.getLargeur(), panelEnvironnement.getTaillePseudoPatch()*panelEnvironnement.getHauteur());
this.panelEnvironnement = panelEnvironnement;
this.addMouseListener(new MouseGCarteListener(this));
this.addMouseMotionListener(new MouseGCarteListener(this));
int taille = panelEnvironnement.getTaillePseudoPatch();
int largeur = panelEnvironnement.getLargeur();
int hauteur = panelEnvironnement.getHauteur();
this.espacementVerticalCarte = espacementVerticalCarte;
this.espacementHorizontalCarte = espacementHorizontalCarte;
this.setBounds(espacementHorizontalCarte, espacementVerticalCarte, taille*largeur, taille*hauteur);
this.setXx(espacementHorizontalCarte);
this.setYy(espacementVerticalCarte);
dessinerBufferImage();
}
@Override
public void paintComponent(Graphics g) {
Graphics2D g2d = genererContexte(g);
super.paintComponents(g);
g2d.drawImage(bufferedImage,0,0,null);
}
public void changerPatch(MouseEvent e) {
int taille = panelEnvironnement.getTaillePseudoPatch();
Terrain terrain = (Terrain) panelEnvironnement.getPanelPrincipal().getPanelTerrains().getListeTerrains().getSelectedValue();
if (terrain != null){
int x = (int)(e.getX()/(double)taille);
int y = (int)(e.getY()/(double)taille);
panelEnvironnement.getCarte().get(y).get(x).setTerrain(terrain);
}
else{
System.out.println("No terrain selected !");
}
dessinerBufferImage();
}
public void actualiser(){
this.setXx(espacementHorizontalCarte);
this.setYy(espacementVerticalCarte);
this.setW(panelEnvironnement.getTaillePseudoPatch()*panelEnvironnement.getLargeur());
this.setH(panelEnvironnement.getTaillePseudoPatch()*panelEnvironnement.getHauteur());
dessinerBufferImage();
}
private void dessinerBufferImage(){
int taille = panelEnvironnement.getTaillePseudoPatch();
int largeur = panelEnvironnement.getLargeur();
int hauteur = panelEnvironnement.getHauteur();
this.setBounds((int)getXx(), (int)getYy(), taille*largeur, taille*hauteur);
bufferedImage = new BufferedImage(taille*largeur,taille*hauteur,BufferedImage.TYPE_INT_RGB );
Graphics2D g = bufferedImage.createGraphics();
for (int i = 0; i < hauteur; i++){
for (int j = 0; j < largeur; j++){
if (panelEnvironnement.getCarte().get(i).get(j).getTerrain() == null){
g.setColor(Color.BLACK);
}
else{
g.setColor(panelEnvironnement.getCarte().get(i).get(j).getTerrain().getCouleur());
}
g.fill(new Rectangle2D.Double(j*taille,i*taille,taille,taille));
}
}
/*Drawing civs*/
for (int i = 0; i < Configuration.civilisations.size(); i++){
Civilisation civ = Configuration.civilisations.get(i);
PseudoPatch pp = startingPositions.get(civ);
if (startingPositions.containsKey(civ)){
g.setColor(civ.getCouleur());
g.fill(new Rectangle2D.Double(pp.getX()*taille,pp.getY()*taille,taille,taille));
g.setColor(Color.DARK_GRAY);
g.drawLine(pp.getX()*taille, pp.getY()*taille, (pp.getX()+1)*taille, pp.getY()*taille);
g.drawLine(pp.getX()*taille, pp.getY()*taille, (pp.getX()+0)*taille, (pp.getY()+1)*taille);
g.drawLine((pp.getX()+1)*taille, pp.getY()*taille, (pp.getX()+1)*taille, (pp.getY()+1)*taille);
g.drawLine(pp.getX()*taille, (pp.getY()+1)*taille, (pp.getX()+1)*taille, (pp.getY()+1)*taille);
}
}
}
public PanelEnvironnement getPanelEnvironnement() {
return panelEnvironnement;
}
public void peindre(MouseEvent e) {
int taille = panelEnvironnement.getTaillePseudoPatch();
int x = (int)(e.getX()/(double)taille);
int y = (int)(e.getY()/(double)taille);
Terrain terrain = (Terrain) panelEnvironnement.getPanelPrincipal().getPanelTerrains().getListeTerrains().getSelectedValue();
Terrain ref = panelEnvironnement.getCarte().get(y).get(x).getTerrain();
if (terrain != null){
Stack<PseudoPatch> patchList = new Stack<PseudoPatch>();
patchList.add(panelEnvironnement.getCarte().get(y).get(x));
panelEnvironnement.getCarte().get(y).get(x).setMark(true);
while (!patchList.isEmpty()) {
peintureDynamique(patchList, terrain, ref);
}
}
else{
System.out.println("No terrain selected!");
}
panelEnvironnement.unmarkAllPatch();
dessinerBufferImage();
}
private void peintureDynamique(Stack<PseudoPatch> patchList, Terrain t, Terrain reference){
PseudoPatch pp = patchList.pop();
pp.setTerrain(t);
int x = pp.getX();
int y = pp.getY();
for (int i = -1 ; i <= 1 ; i++){
for (int j = -1 ; j <= 1; j++){
if (x + j >= 0 &&
y + i >= 0 &&
x + j < panelEnvironnement.getCarte().get(0).size() &&
y + i < panelEnvironnement.getCarte().size()
){
PseudoPatch newPp = panelEnvironnement.getCarte().get(y+i).get(x+j);
if (newPp.getTerrain().equals(reference) && !newPp.isMark()){
patchList.add(newPp);
newPp.setMark(true);
}
}
}
}
}
public void afficherPopup(MouseEvent e) {
popup = new JPopupMenu("Actions sp_ciales");
JMenuItem editerPhero = new JMenuItem("Emplacement de d_part");
editerPhero.addActionListener(new ActionsMenuGCarte(this,0,e));
editerPhero.setIcon(new ImageIcon(this.getClass().getResource("../../icones/pencil.png")));
popup.add(editerPhero);
popup.show(this, e.getX(), e.getY());
}
public PseudoPatch getTargetPseudoPatch(MouseEvent e) {
int taille = panelEnvironnement.getTaillePseudoPatch();
int x = (int)(e.getX()/(double)taille);
int y = (int)(e.getY()/(double)taille);
return panelEnvironnement.getCarte().get(y).get(x);
}
public void addStartingPosition(Civilisation c, PseudoPatch pp){
this.startingPositions.put(c, pp);
actualiser();
}
public HashMap<Civilisation, PseudoPatch> getStartingPositions() {
return startingPositions;
}
}
| [
"julien.nigon@orange.fr"
] | julien.nigon@orange.fr |
208827807a78f9bc384747901b0afb6095963171 | d880de435f1b654c52bbc916f93f794426c052a7 | /src/main/java/org/yawlfoundation/yawl/editor/actions/element/DropTaskDecompositionAction.java | 9861a4ddc48e2da6d2d1894b38cbc85ee3d538e2 | [] | no_license | itiu/yawl-editor-zmq | f76b865c4b545990eb1ed62cd6323234fb2f2d4c | bc459a34108f33df121d205e358a1a25dc5ac405 | refs/heads/master | 2020-05-29T09:55:15.670624 | 2011-09-26T14:40:15 | 2011-09-26T14:40:15 | 2,443,701 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 3,218 | java | /*
* Created on 09/10/2003
* YAWLEditor v1.0
*
* @author Lindsay Bradford
*
*
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* 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 org.yawlfoundation.yawl.editor.actions.element;
import org.yawlfoundation.yawl.editor.actions.net.YAWLSelectedNetAction;
import org.yawlfoundation.yawl.editor.elements.model.YAWLTask;
import org.yawlfoundation.yawl.editor.net.NetGraph;
import org.yawlfoundation.yawl.editor.swing.TooltipTogglingWidget;
import org.yawlfoundation.yawl.editor.specification.SpecificationUndoManager;
import javax.swing.*;
import java.awt.event.ActionEvent;
public class DropTaskDecompositionAction extends YAWLSelectedNetAction
implements TooltipTogglingWidget {
/**
*
*/
private static final long serialVersionUID = 1L;
private NetGraph graph;
private YAWLTask task;
{
putValue(Action.SHORT_DESCRIPTION, getDisabledTooltipText());
putValue(Action.NAME, "Drop Task Decomposition...");
putValue(Action.LONG_DESCRIPTION, "Remove the current decomposition from this task.");
putValue(Action.SMALL_ICON, getPNGIcon("chart_organisation_delete"));
putValue(Action.MNEMONIC_KEY, new Integer(java.awt.event.KeyEvent.VK_R));
}
public DropTaskDecompositionAction(YAWLTask task, NetGraph graph) {
super();
this.task = task;
this.graph = graph;
}
public void actionPerformed(ActionEvent event) {
if (confirmed()) {
graph.setTaskDecomposition(task, null);
graph.clearSelection();
SpecificationUndoManager.getInstance().setDirty(true);
}
}
public String getEnabledTooltipText() {
return " Remove the current decomposition from this task ";
}
public String getDisabledTooltipText() {
return " You need to have selected a task with a decomposition to drop ";
}
public boolean shouldBeEnabled() {
return (task.getDecomposition() != null);
}
private boolean confirmed() {
Object[] choices = {"Drop", "Cancel"};
int selection = JOptionPane.showOptionDialog(null,
"This will permanently remove the selected Decomposition\n" +
"and all its associated mappings from this Task.\n" +
"This action cannot be undone. Are you sure?",
"Confirm Drop Decomposition", JOptionPane.YES_NO_OPTION,
JOptionPane.WARNING_MESSAGE, null, choices, choices[1]);
return selection == 0 ;
}
} | [
"ValeriyBushenev@gmail.com"
] | ValeriyBushenev@gmail.com |
4c46a00938bd0c8db0a088773315b8c1a6ea7f8f | 53097262c2843dd7f056cf37a0ac08a5375c093e | /src/main/java/com/pack/service/impl/DemandModuleService.java | dea8edf33c983c42637b96f04314b097d6739007 | [] | no_license | ljh205sy/onlinepack | 2ae248608c0339117d6982466b1d0a003b8e8732 | a62dc54b127fe0627f0e8499efbe3aaa9acccc7e | refs/heads/master | 2022-06-21T06:07:24.189298 | 2020-01-08T08:37:58 | 2020-01-08T08:37:58 | 220,665,710 | 0 | 0 | null | 2022-06-17T02:36:49 | 2019-11-09T15:54:52 | Java | UTF-8 | Java | false | false | 678 | java | package com.pack.service.impl;
import com.pack.entity.DemandModule;
import com.pack.repository.BaseRepository;
import com.pack.repository.DemandModuleRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.transaction.Transactional;
/**
* @Author: liujinhui
* @Date: 2019/11/9 10:03
*/
@Service
@Transactional
public class DemandModuleService extends BaseServiceImpl<DemandModule, String> {
@Autowired
private DemandModuleRepository demandModuleRepository;
@Override
public BaseRepository<DemandModule, String> getRepository() {
return demandModuleRepository;
}
}
| [
"liujinhui@vrvmail.com.cn"
] | liujinhui@vrvmail.com.cn |
8d4bf40c8127a2d55142c736a4a26cf27c4821dc | 8c42033c11d92f816492c0019d1eeff0ee7fc041 | /GestionInterventionApp/app/src/test/java/com/example/gestionintervention/ExampleUnitTest.java | e3be7ea5404d61223653a9416bc9bd449d584881 | [] | no_license | Choukriel/Gestion_Interventions | ab07cca897d8392dd68b8d4404af6ef3a6994a17 | 3837204d56092fb0d6f5e946514550f85e1d4148 | refs/heads/master | 2023-06-17T07:15:25.337138 | 2021-07-17T13:05:05 | 2021-07-17T13:05:05 | 287,078,591 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 393 | java | package com.example.gestionintervention;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() {
assertEquals(4, 2 + 2);
}
}
| [
"choukrielou@gmail.com"
] | choukrielou@gmail.com |
1c90819d3e8265000633e5895d09cfe0ac15ad64 | 6c5a8273b3c677781612d18361e265a152922b6b | /src/com/bvan/javaoop/lessons5_6/factorial/FactorialRunner.java | 3ddefa75e8f3ceb15096bd10c5f0b000e79946ca | [] | no_license | bohdanvan/javaoop-group84 | e0a5683dedc4d7fc99d92025f38e981a01d7e240 | 62b01935d1ff2a821d7336ac28c83982c385ae3b | refs/heads/master | 2020-03-27T06:34:51.827162 | 2018-10-06T20:36:31 | 2018-10-06T20:36:31 | 146,116,629 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 677 | java | package com.bvan.javaoop.lessons5_6.factorial;
import java.math.BigInteger;
/**
* @author bvanchuhov
*/
public class FactorialRunner {
public static void main(String[] args) {
try {
BigInteger res = Factorial.factorial(-10);
System.out.println(res);
} catch (IllegalStateException e) {
System.out.println("Illegal State: " + e.getMessage());
} catch (IllegalArgumentException e) {
System.out.println("Illegal Argument: " + e.getMessage());
} catch (RuntimeException e) {
} finally {
System.out.println("Finally");
}
System.out.println("Bye");
}
}
| [
"bohdan.vanchuhov@globallogic.com"
] | bohdan.vanchuhov@globallogic.com |
457d71f3dfaf8e915566363c330e4bed6e14a0a4 | ac93b511b86c5596dc414b103441d15ef9044169 | /weatherApp/src/main/java/com/weatherApp/weatherApp/MyUI.java | 43afbbc8b97841c35c6cf87437fac63c60a09c23 | [] | no_license | emrekiziltepe/WeatherApp | 0c1afdb18b0e3917bc451ce814222afc2fb3d409 | fbfd2e146896e0be1b94f4273d75cba60470014a | refs/heads/master | 2021-08-22T07:48:41.662786 | 2017-11-29T17:27:26 | 2017-11-29T17:27:26 | 110,876,771 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,078 | java | package com.weatherApp.weatherApp;
import com.vaadin.ui.*;
import org.springframework.beans.factory.annotation.Autowired;
import com.vaadin.annotations.Theme;
import com.vaadin.server.VaadinRequest;
import com.vaadin.spring.annotation.SpringUI;
@SpringUI
@Theme("valo")
public class MyUI extends UI {
@Autowired
private WebService service;
private Weather wthr;
@Override
protected void init(VaadinRequest request) {
final TextField veri = new TextField("Hava durumunu öğrenmek istediğiniz şehri giriniz: ");
final Button tamam = new Button("Tamam");
final VerticalLayout layout = new VerticalLayout();
tamam.addClickListener( e -> {
wthr = service.getWeather(veri.getValue());
String dereceString = String.valueOf(wthr.getMain().toString());
layout.addComponent(new Label(veri.getValue() + " sehrinin anlık sıcaklıgı: "+ dereceString + "°C"));
});
layout.addComponents(veri,tamam);
setContent(layout);
}
}
| [
"noreply@github.com"
] | noreply@github.com |
57b21e399427455061fa63fbb1f65fe3754750c2 | a3fe5db4cf9f5dc75b8331b1fe69de13e0549587 | /activemq/openwire/v7/JournalTopicAckMarshaller.java | 3e1ba5fd6dd8a7afffa3557dfe73df7fba1c3a2d | [] | no_license | ShengtaoHou/software-recovery | 7cd8e1a0aabadb808a0f00e5b0503a582c8d3c89 | 72a3dde6a0cba56f851c29008df94ae129a05d03 | refs/heads/master | 2020-09-26T08:25:54.952083 | 2019-12-11T07:32:57 | 2019-12-11T07:32:57 | 226,215,103 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,612 | java | //
// Decompiled by Procyon v0.5.36
//
package org.apache.activemq.openwire.v7;
import java.io.DataOutput;
import java.io.IOException;
import org.apache.activemq.command.TransactionId;
import org.apache.activemq.command.MessageId;
import org.apache.activemq.command.ActiveMQDestination;
import org.apache.activemq.openwire.BooleanStream;
import java.io.DataInput;
import org.apache.activemq.openwire.OpenWireFormat;
import org.apache.activemq.command.JournalTopicAck;
import org.apache.activemq.command.DataStructure;
public class JournalTopicAckMarshaller extends BaseDataStreamMarshaller
{
@Override
public byte getDataStructureType() {
return 50;
}
@Override
public DataStructure createObject() {
return new JournalTopicAck();
}
@Override
public void tightUnmarshal(final OpenWireFormat wireFormat, final Object o, final DataInput dataIn, final BooleanStream bs) throws IOException {
super.tightUnmarshal(wireFormat, o, dataIn, bs);
final JournalTopicAck info = (JournalTopicAck)o;
info.setDestination((ActiveMQDestination)this.tightUnmarsalNestedObject(wireFormat, dataIn, bs));
info.setMessageId((MessageId)this.tightUnmarsalNestedObject(wireFormat, dataIn, bs));
info.setMessageSequenceId(this.tightUnmarshalLong(wireFormat, dataIn, bs));
info.setSubscritionName(this.tightUnmarshalString(dataIn, bs));
info.setClientId(this.tightUnmarshalString(dataIn, bs));
info.setTransactionId((TransactionId)this.tightUnmarsalNestedObject(wireFormat, dataIn, bs));
}
@Override
public int tightMarshal1(final OpenWireFormat wireFormat, final Object o, final BooleanStream bs) throws IOException {
final JournalTopicAck info = (JournalTopicAck)o;
int rc = super.tightMarshal1(wireFormat, o, bs);
rc += this.tightMarshalNestedObject1(wireFormat, info.getDestination(), bs);
rc += this.tightMarshalNestedObject1(wireFormat, info.getMessageId(), bs);
rc += this.tightMarshalLong1(wireFormat, info.getMessageSequenceId(), bs);
rc += this.tightMarshalString1(info.getSubscritionName(), bs);
rc += this.tightMarshalString1(info.getClientId(), bs);
rc += this.tightMarshalNestedObject1(wireFormat, info.getTransactionId(), bs);
return rc + 0;
}
@Override
public void tightMarshal2(final OpenWireFormat wireFormat, final Object o, final DataOutput dataOut, final BooleanStream bs) throws IOException {
super.tightMarshal2(wireFormat, o, dataOut, bs);
final JournalTopicAck info = (JournalTopicAck)o;
this.tightMarshalNestedObject2(wireFormat, info.getDestination(), dataOut, bs);
this.tightMarshalNestedObject2(wireFormat, info.getMessageId(), dataOut, bs);
this.tightMarshalLong2(wireFormat, info.getMessageSequenceId(), dataOut, bs);
this.tightMarshalString2(info.getSubscritionName(), dataOut, bs);
this.tightMarshalString2(info.getClientId(), dataOut, bs);
this.tightMarshalNestedObject2(wireFormat, info.getTransactionId(), dataOut, bs);
}
@Override
public void looseUnmarshal(final OpenWireFormat wireFormat, final Object o, final DataInput dataIn) throws IOException {
super.looseUnmarshal(wireFormat, o, dataIn);
final JournalTopicAck info = (JournalTopicAck)o;
info.setDestination((ActiveMQDestination)this.looseUnmarsalNestedObject(wireFormat, dataIn));
info.setMessageId((MessageId)this.looseUnmarsalNestedObject(wireFormat, dataIn));
info.setMessageSequenceId(this.looseUnmarshalLong(wireFormat, dataIn));
info.setSubscritionName(this.looseUnmarshalString(dataIn));
info.setClientId(this.looseUnmarshalString(dataIn));
info.setTransactionId((TransactionId)this.looseUnmarsalNestedObject(wireFormat, dataIn));
}
@Override
public void looseMarshal(final OpenWireFormat wireFormat, final Object o, final DataOutput dataOut) throws IOException {
final JournalTopicAck info = (JournalTopicAck)o;
super.looseMarshal(wireFormat, o, dataOut);
this.looseMarshalNestedObject(wireFormat, info.getDestination(), dataOut);
this.looseMarshalNestedObject(wireFormat, info.getMessageId(), dataOut);
this.looseMarshalLong(wireFormat, info.getMessageSequenceId(), dataOut);
this.looseMarshalString(info.getSubscritionName(), dataOut);
this.looseMarshalString(info.getClientId(), dataOut);
this.looseMarshalNestedObject(wireFormat, info.getTransactionId(), dataOut);
}
}
| [
"shengtao@ShengtaoHous-MacBook-Pro.local"
] | shengtao@ShengtaoHous-MacBook-Pro.local |
84b6d1d1e9a913733c5631dd2fd0f146d64b4a4f | 447520f40e82a060368a0802a391697bc00be96f | /apks/playstore_apps/de_number26_android/source/com/google/maps/android/PolyUtil.java | 34210f7efb4098b8afc7262ea99b3b7f302e4d38 | [
"Apache-2.0"
] | permissive | iantal/AndroidPermissions | 7f3343a9c29d82dbcd4ecd98b3a50ddf8d179465 | d623b732734243590b5f004d167e542e2e2ae249 | refs/heads/master | 2023-07-19T01:29:26.689186 | 2019-09-30T19:01:42 | 2019-09-30T19:01:42 | 107,239,248 | 0 | 0 | Apache-2.0 | 2023-07-16T07:41:38 | 2017-10-17T08:22:57 | null | UTF-8 | Java | false | false | 15,365 | java | package com.google.maps.android;
import com.google.android.gms.maps.model.LatLng;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Stack;
public class PolyUtil
{
private static final double DEFAULT_TOLERANCE = 0.1D;
private PolyUtil() {}
public static boolean containsLocation(double paramDouble1, double paramDouble2, List<LatLng> paramList, boolean paramBoolean)
{
int i = paramList.size();
if (i == 0) {
return false;
}
double d3 = Math.toRadians(paramDouble1);
double d4 = Math.toRadians(paramDouble2);
LatLng localLatLng = (LatLng)paramList.get(i - 1);
paramDouble1 = Math.toRadians(localLatLng.latitude);
paramDouble2 = Math.toRadians(localLatLng.longitude);
paramList = paramList.iterator();
int j;
for (i = 0; paramList.hasNext(); i = j)
{
localLatLng = (LatLng)paramList.next();
double d5 = MathUtil.wrap(d4 - paramDouble2, -3.141592653589793D, 3.141592653589793D);
if ((d3 == paramDouble1) && (d5 == 0.0D)) {
return true;
}
double d2 = Math.toRadians(localLatLng.latitude);
double d1 = Math.toRadians(localLatLng.longitude);
j = i;
if (intersects(paramDouble1, d2, MathUtil.wrap(d1 - paramDouble2, -3.141592653589793D, 3.141592653589793D), d3, d5, paramBoolean)) {
j = i + 1;
}
paramDouble1 = d2;
paramDouble2 = d1;
}
return (i & 0x1) != 0;
}
public static boolean containsLocation(LatLng paramLatLng, List<LatLng> paramList, boolean paramBoolean)
{
return containsLocation(paramLatLng.latitude, paramLatLng.longitude, paramList, paramBoolean);
}
public static List<LatLng> decode(String paramString)
{
int i2 = paramString.length();
ArrayList localArrayList = new ArrayList();
int m = 0;
int i = m;
int j = i;
int k = i;
i = m;
if (i < i2)
{
m = 0;
int n = 1;
for (int i1 = i;; i1 = i)
{
i = i1 + 1;
i1 = paramString.charAt(i1) - '?' - 1;
n += (i1 << m);
m += 5;
if (i1 < 31)
{
if ((n & 0x1) != 0) {
m = n >> 1;
} else {
m = n >> 1;
}
i1 = m + k;
k = 0;
m = 1;
for (n = i;; n = i)
{
i = n + 1;
n = paramString.charAt(n) - '?' - 1;
m += (n << k);
k += 5;
if (n < 31)
{
if ((m & 0x1) != 0) {
k = m >> 1;
} else {
k = m >> 1;
}
j += k;
localArrayList.add(new LatLng(i1 * 1.0E-5D, j * 1.0E-5D));
k = i1;
break;
}
}
}
}
}
return localArrayList;
}
public static double distanceToLine(LatLng paramLatLng1, LatLng paramLatLng2, LatLng paramLatLng3)
{
if (paramLatLng2.equals(paramLatLng3)) {
return SphericalUtil.computeDistanceBetween(paramLatLng3, paramLatLng1);
}
double d1 = Math.toRadians(paramLatLng1.latitude);
double d2 = Math.toRadians(paramLatLng1.longitude);
double d3 = Math.toRadians(paramLatLng2.latitude);
double d4 = Math.toRadians(paramLatLng2.longitude);
double d6 = Math.toRadians(paramLatLng3.latitude);
double d5 = Math.toRadians(paramLatLng3.longitude);
d6 -= d3;
d5 -= d4;
d1 = ((d1 - d3) * d6 + (d2 - d4) * d5) / (d6 * d6 + d5 * d5);
if (d1 <= 0.0D) {
return SphericalUtil.computeDistanceBetween(paramLatLng1, paramLatLng2);
}
if (d1 >= 1.0D) {
return SphericalUtil.computeDistanceBetween(paramLatLng1, paramLatLng3);
}
return SphericalUtil.computeDistanceBetween(new LatLng(paramLatLng1.latitude - paramLatLng2.latitude, paramLatLng1.longitude - paramLatLng2.longitude), new LatLng((paramLatLng3.latitude - paramLatLng2.latitude) * d1, d1 * (paramLatLng3.longitude - paramLatLng2.longitude)));
}
public static String encode(List<LatLng> paramList)
{
StringBuffer localStringBuffer = new StringBuffer();
paramList = paramList.iterator();
long l1 = 0L;
long l3;
for (long l2 = 0L; paramList.hasNext(); l2 = l3)
{
LatLng localLatLng = (LatLng)paramList.next();
long l4 = Math.round(localLatLng.latitude * 100000.0D);
l3 = Math.round(localLatLng.longitude * 100000.0D);
encode(l4 - l1, localStringBuffer);
encode(l3 - l2, localStringBuffer);
l1 = l4;
}
return localStringBuffer.toString();
}
private static void encode(long paramLong, StringBuffer paramStringBuffer)
{
if (paramLong < 0L) {
paramLong <<= 1;
}
for (paramLong <<= 1; paramLong >= 32L; paramLong >>= 5) {
paramStringBuffer.append(Character.toChars((int)((0x20 | 0x1F & paramLong) + 63L)));
}
paramStringBuffer.append(Character.toChars((int)(paramLong + 63L)));
}
private static boolean intersects(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, boolean paramBoolean)
{
if (((paramDouble5 >= 0.0D) && (paramDouble5 >= paramDouble3)) || ((paramDouble5 < 0.0D) && (paramDouble5 < paramDouble3))) {
return false;
}
if (paramDouble4 <= -1.5707963267948966D) {
return false;
}
if ((paramDouble1 > -1.5707963267948966D) && (paramDouble2 > -1.5707963267948966D) && (paramDouble1 < 1.5707963267948966D))
{
if (paramDouble2 >= 1.5707963267948966D) {
return false;
}
if (paramDouble3 <= -3.141592653589793D) {
return false;
}
double d = ((paramDouble3 - paramDouble5) * paramDouble1 + paramDouble2 * paramDouble5) / paramDouble3;
if ((paramDouble1 >= 0.0D) && (paramDouble2 >= 0.0D) && (paramDouble4 < d)) {
return false;
}
if ((paramDouble1 <= 0.0D) && (paramDouble2 <= 0.0D) && (paramDouble4 >= d)) {
return true;
}
if (paramDouble4 >= 1.5707963267948966D) {
return true;
}
if (paramBoolean)
{
if (Math.tan(paramDouble4) < tanLatGC(paramDouble1, paramDouble2, paramDouble3, paramDouble5)) {}
}
else {
while (MathUtil.mercator(paramDouble4) >= mercatorLatRhumb(paramDouble1, paramDouble2, paramDouble3, paramDouble5)) {
return true;
}
}
return false;
}
return false;
}
public static boolean isClosedPolygon(List<LatLng> paramList)
{
return ((LatLng)paramList.get(0)).equals((LatLng)paramList.get(paramList.size() - 1));
}
public static boolean isLocationOnEdge(LatLng paramLatLng, List<LatLng> paramList, boolean paramBoolean)
{
return isLocationOnEdge(paramLatLng, paramList, paramBoolean, 0.1D);
}
public static boolean isLocationOnEdge(LatLng paramLatLng, List<LatLng> paramList, boolean paramBoolean, double paramDouble)
{
return isLocationOnEdgeOrPath(paramLatLng, paramList, true, paramBoolean, paramDouble);
}
private static boolean isLocationOnEdgeOrPath(LatLng paramLatLng, List<LatLng> paramList, boolean paramBoolean1, boolean paramBoolean2, double paramDouble)
{
int i = paramList.size();
if (i == 0) {
return false;
}
double d12 = paramDouble / 6371009.0D;
double d10 = MathUtil.hav(d12);
double d7 = Math.toRadians(paramLatLng.latitude);
double d11 = Math.toRadians(paramLatLng.longitude);
if (paramBoolean1) {
i -= 1;
} else {
i = 0;
}
paramLatLng = (LatLng)paramList.get(i);
double d5 = Math.toRadians(paramLatLng.latitude);
double d1 = Math.toRadians(paramLatLng.longitude);
double d2;
double d3;
if (paramBoolean2)
{
paramLatLng = paramList.iterator();
paramDouble = d7;
d2 = d1;
for (d1 = d5; paramLatLng.hasNext(); d1 = d3)
{
paramList = (LatLng)paramLatLng.next();
d3 = Math.toRadians(paramList.latitude);
d4 = Math.toRadians(paramList.longitude);
if (isOnSegmentGC(d1, d2, d3, d4, paramDouble, d11, d10)) {
return true;
}
d2 = d4;
}
}
paramDouble = d12 + d7;
double d4 = MathUtil.mercator(d5);
double d13 = MathUtil.mercator(d7);
double[] arrayOfDouble = new double[3];
paramLatLng = paramList.iterator();
while (paramLatLng.hasNext())
{
paramList = (LatLng)paramLatLng.next();
double d6 = Math.toRadians(paramList.latitude);
double d8 = MathUtil.mercator(d6);
double d9 = Math.toRadians(paramList.longitude);
d2 = paramDouble;
d3 = d6;
if (Math.max(d5, d6) >= d7 - d12)
{
d2 = paramDouble;
d3 = d6;
if (Math.min(d5, d6) <= paramDouble)
{
d5 = MathUtil.wrap(d9 - d1, -3.141592653589793D, 3.141592653589793D);
d1 = MathUtil.wrap(d11 - d1, -3.141592653589793D, 3.141592653589793D);
arrayOfDouble[0] = d1;
arrayOfDouble[1] = (d1 + 6.283185307179586D);
arrayOfDouble[2] = (d1 - 6.283185307179586D);
int j = arrayOfDouble.length;
i = 0;
d1 = d6;
for (;;)
{
d2 = paramDouble;
d3 = d1;
if (i >= j) {
break;
}
d3 = arrayOfDouble[i];
d6 = d8 - d4;
double d14 = d5 * d5 + d6 * d6;
d2 = 0.0D;
if (d14 > 0.0D) {
d2 = MathUtil.clamp((d3 * d5 + (d13 - d4) * d6) / d14, 0.0D, 1.0D);
}
if (MathUtil.havDistance(d7, MathUtil.inverseMercator(d4 + d2 * d6), d3 - d2 * d5) < d10) {
return true;
}
i += 1;
}
}
}
d1 = d9;
d4 = d8;
paramDouble = d2;
d5 = d3;
}
return false;
}
public static boolean isLocationOnPath(LatLng paramLatLng, List<LatLng> paramList, boolean paramBoolean)
{
return isLocationOnPath(paramLatLng, paramList, paramBoolean, 0.1D);
}
public static boolean isLocationOnPath(LatLng paramLatLng, List<LatLng> paramList, boolean paramBoolean, double paramDouble)
{
return isLocationOnEdgeOrPath(paramLatLng, paramList, false, paramBoolean, paramDouble);
}
private static boolean isOnSegmentGC(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6, double paramDouble7)
{
double d1 = MathUtil.havDistance(paramDouble1, paramDouble5, paramDouble2 - paramDouble6);
if (d1 <= paramDouble7) {
return true;
}
double d2 = MathUtil.havDistance(paramDouble3, paramDouble5, paramDouble4 - paramDouble6);
if (d2 <= paramDouble7) {
return true;
}
paramDouble5 = sinDeltaBearing(paramDouble1, paramDouble2, paramDouble3, paramDouble4, paramDouble5, paramDouble6);
paramDouble5 = MathUtil.havFromSin(MathUtil.sinFromHav(d1) * paramDouble5);
boolean bool = false;
if (paramDouble5 > paramDouble7) {
return false;
}
paramDouble1 = MathUtil.havDistance(paramDouble1, paramDouble3, paramDouble2 - paramDouble4);
paramDouble2 = (1.0D - 2.0D * paramDouble1) * paramDouble5 + paramDouble1;
if (d1 <= paramDouble2)
{
if (d2 > paramDouble2) {
return false;
}
if (paramDouble1 < 0.74D) {
return true;
}
paramDouble1 = 1.0D - 2.0D * paramDouble5;
if (MathUtil.sinSumFromHav((d1 - paramDouble5) / paramDouble1, (d2 - paramDouble5) / paramDouble1) > 0.0D) {
bool = true;
}
return bool;
}
return false;
}
private static double mercatorLatRhumb(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4)
{
return (MathUtil.mercator(paramDouble1) * (paramDouble3 - paramDouble4) + MathUtil.mercator(paramDouble2) * paramDouble4) / paramDouble3;
}
public static List<LatLng> simplify(List<LatLng> paramList, double paramDouble)
{
int k = paramList.size();
if (k < 1) {
throw new IllegalArgumentException("Polyline must have at least 1 point");
}
if (paramDouble <= 0.0D) {
throw new IllegalArgumentException("Tolerance must be greater than zero");
}
boolean bool = isClosedPolygon(paramList);
Object localObject1 = null;
if (bool)
{
localObject1 = (LatLng)paramList.get(paramList.size() - 1);
paramList.remove(paramList.size() - 1);
paramList.add(new LatLng(((LatLng)localObject1).latitude + 1.0E-11D, ((LatLng)localObject1).longitude + 1.0E-11D));
}
Object localObject2 = new Stack();
double[] arrayOfDouble = new double[k];
int j = 0;
int i = 0;
arrayOfDouble[0] = 1.0D;
int m = k - 1;
arrayOfDouble[m] = 1.0D;
if (k > 2)
{
((Stack)localObject2).push(new int[] { 0, m });
k = 0;
for (;;)
{
j = i;
if (((Stack)localObject2).size() <= 0) {
break;
}
int[] arrayOfInt = (int[])((Stack)localObject2).pop();
j = arrayOfInt[i] + 1;
double d2;
for (double d1 = 0.0D; j < arrayOfInt[1]; d1 = d2)
{
double d3 = distanceToLine((LatLng)paramList.get(j), (LatLng)paramList.get(arrayOfInt[i]), (LatLng)paramList.get(arrayOfInt[1]));
d2 = d1;
if (d3 > d1)
{
d2 = d3;
k = j;
}
j += 1;
i = 0;
}
if (d1 > paramDouble)
{
arrayOfDouble[k] = d1;
((Stack)localObject2).push(new int[] { arrayOfInt[0], k });
((Stack)localObject2).push(new int[] { k, arrayOfInt[1] });
}
i = 0;
}
}
if (bool)
{
paramList.remove(paramList.size() - 1);
paramList.add(localObject1);
}
localObject1 = new ArrayList();
paramList = paramList.iterator();
while (paramList.hasNext())
{
localObject2 = (LatLng)paramList.next();
if (arrayOfDouble[j] != 0.0D) {
((ArrayList)localObject1).add(localObject2);
}
j += 1;
}
return localObject1;
}
private static double sinDeltaBearing(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, double paramDouble5, double paramDouble6)
{
double d3 = Math.sin(paramDouble1);
double d1 = Math.cos(paramDouble3);
double d2 = Math.cos(paramDouble5);
paramDouble6 -= paramDouble2;
double d4 = paramDouble4 - paramDouble2;
paramDouble2 = Math.sin(paramDouble6) * d2;
paramDouble4 = Math.sin(d4) * d1;
paramDouble5 = Math.sin(paramDouble5 - paramDouble1);
d3 = 2.0D * d3;
paramDouble5 += d2 * d3 * MathUtil.hav(paramDouble6);
paramDouble1 = Math.sin(paramDouble3 - paramDouble1) + d3 * d1 * MathUtil.hav(d4);
paramDouble3 = (paramDouble2 * paramDouble2 + paramDouble5 * paramDouble5) * (paramDouble4 * paramDouble4 + paramDouble1 * paramDouble1);
if (paramDouble3 <= 0.0D) {
return 1.0D;
}
return (paramDouble2 * paramDouble1 - paramDouble5 * paramDouble4) / Math.sqrt(paramDouble3);
}
private static double tanLatGC(double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4)
{
return (Math.tan(paramDouble1) * Math.sin(paramDouble3 - paramDouble4) + Math.tan(paramDouble2) * Math.sin(paramDouble4)) / Math.sin(paramDouble3);
}
}
| [
"antal.micky@yahoo.com"
] | antal.micky@yahoo.com |
b5038e5e478633d23700b3c5177ab3538b19c052 | 4ecdc8f45e26e326dae1c5d521d18e561b728232 | /library/src/main/java/com/router/civilization/library/eventbus/EventBusUtils.java | 5dbfbeca60c258871d736c6e456d608ba18b9436 | [] | no_license | tian-y05/CivilizationTest | 46a0310631356f9115626c608178a82fb987a399 | d18ec94c657dbeac01dfcc53fd2a73b32a19700b | refs/heads/master | 2020-12-12T01:10:21.884495 | 2020-01-15T07:38:10 | 2020-01-15T07:38:11 | 234,004,819 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,213 | java | package com.router.civilization.library.eventbus;
import com.router.civilization.library.eventbus.EventBusMessage;
import org.greenrobot.eventbus.EventBus;
/**
* Created by tian
* on 2019/7/1.
*/
public class EventBusUtils {
private EventBusUtils() {
}
/**
* 注册 EventBus
*
* @param subscriber
*/
public static void register(Object subscriber) {
EventBus eventBus = EventBus.getDefault();
if (!eventBus.isRegistered(subscriber)) {
eventBus.register(subscriber);
}
}
/**
* 解除注册 EventBus
*
* @param subscriber
*/
public static void unregister(Object subscriber) {
EventBus eventBus = EventBus.getDefault();
if (eventBus.isRegistered(subscriber)) {
eventBus.unregister(subscriber);
}
}
/**
* 发送事件消息
*
* @param event
*/
public static void post(EventBusMessage event) {
EventBus.getDefault().post(event);
}
/**
* 发送粘性事件消息
*
* @param event
*/
public static void postSticky(EventBusMessage event) {
EventBus.getDefault().postSticky(event);
}
}
| [
"912853997@qq.com"
] | 912853997@qq.com |
bf28a4ab9edd813a3752e77109f9b9c8b5fad9af | 01975c626f07f3fd1371ddfae48efc52108dfe9a | /src/org/fernwood/jbasic/funcs/CosFunction.java | 1012c24e177941df8d205feba628a27abacd36f4 | [] | no_license | tucats/JBasic | 3d1285162430c314c3dffabdf95e8b9afcca90dc | d2bf0b3b06410dbaf2b41a4abee41c9faa3dffb9 | refs/heads/master | 2022-09-29T08:34:40.827317 | 2022-09-03T16:33:22 | 2022-09-03T16:33:22 | 16,550,357 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,977 | java | /*
* THIS SOURCE FILE IS PART OF JBASIC, AN OPEN SOURCE PUBLICLY AVAILABLE
* JAVA SOFTWARE PACKAGE HOSTED BY SOURCEFORGE.NET
*
* THIS SOFTWARE IS PROVIDED VIA THE GNU PUBLIC LICENSE AND IS FREELY
* AVAILABLE FOR ANY PURPOSE COMMERCIAL OR OTHERWISE AS LONG AS THE AUTHORSHIP
* AND COPYRIGHT INFORMATION IS RETAINED INTACT AND APPROPRIATELY VISIBLE
* TO THE END USER.
*
* SEE THE PROJECT FILE AT HTTP://WWW.SOURCEFORGE.NET/PROJECTS/JBASIC FOR
* MORE INFORMATION.
*
* COPYRIGHT 2003-2011 BY TOM COLE, TOMCOLE@USERS.SF.NET
*
*/
package org.fernwood.jbasic.funcs;
import org.fernwood.jbasic.Status;
import org.fernwood.jbasic.runtime.ArgumentList;
import org.fernwood.jbasic.runtime.JBasicException;
import org.fernwood.jbasic.runtime.SymbolTable;
import org.fernwood.jbasic.value.Value;
/**
<b>COS()</b> JBasic Function
* <p>
* <table>
* <tr><td><b>Description:</b></td><td>Calculate COSINE of argument in radians.</td></tr>
* <tr><td><b>Invocation:</b></td><td><code>d2 = COS( d1 )</code></td></tr>
* <tr><td><b>Returns:</b></td><td>Double</td></tr>
* </table>
* <p>
* Calculates the trigonometric cosine of an angle, expressed in
* radians, and returns the result as a floating point number.
* @author cole
*
*/
public class CosFunction extends JBasicFunction {
/**
* Runtime execution of the function via _CALLF
*
* @param arglist the function argument list and count already
* popped from the runtime data stack
* @param symbols the currently active symbol table
* @return a Value containing the function result.
* @throws JBasicException if an argument or execution error occurs
*/
public Value run(final ArgumentList arglist, final SymbolTable symbols) throws JBasicException {
arglist.validate(1, 1, new int[] {Value.NUMBER});
double dv = 0.0;
try {
dv = Math.cos(arglist.doubleElement(0));
} catch (Exception e ) {
throw new JBasicException(Status.ARGTYPE, e.toString());
}
return new Value(dv); }
}
| [
"tom.cole@nc.rr.com"
] | tom.cole@nc.rr.com |
644e87c70444b4bf8a6cfc04254ce855c071c6f6 | 1792919440aff9f82dc81f571ea5f08abce87984 | /src/game/friendly/turrets/XBow.java | 4207570fbaee9539d112976de5516b886d1d4870 | [] | no_license | CodyRichter/GameEngine | 4be3dd61c38f19ee618753a59551789d2d486ea8 | ed11b3d406c8762a0a3ef93e45f34c82a9b1c15d | refs/heads/master | 2021-09-23T18:46:28.155754 | 2018-09-26T14:59:56 | 2018-09-26T14:59:56 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,199 | java | package game.friendly.turrets;
import base.Unit;
import game.Startup;
import game.friendly.Projectile;
import java.util.Timer;
import java.util.TimerTask;
/**
* GameEngine - game.friendly.turrets
*
* @author Cannon
* @version 1.0
*/
public class XBow extends Turret {
private static Timer timer = new Timer();
private static boolean isComplete = true;
public static final int COST = 750;
protected static int cooldown = 60;
protected static int damageAmount = 1;
public XBow() {
super(15, damageAmount, 50, 10);
this.setSprite("xbow");
}
@Override
public void attack(Unit u) {
Timer t = new Timer();
Turret turret = this;
Projectile p = new Projectile();
p.spawn(turret);
t.schedule(new TimerTask() {
@Override
public void run() {
Projectile p = new Projectile();
p.spawn(turret);
}
}, 300);
t.schedule(new TimerTask() {
@Override
public void run() {
Projectile p = new Projectile();
p.spawn(turret);
}
}, 600);
doingAction = true;
//Sets Timer For Cooldown
Timer t2 = new Timer();
t2.schedule(new TimerTask() {
@Override
public void run() {
doingAction = false;
currentlyAttacking = false;
}
}, (int)(delayBetweenAttacks*1000));
}
public String toString(){return "X-Bow";}
public static void startCooldown()
{
if (Startup.ADMINMODE && Startup.NOCOOLDOWN) return;
isComplete = false;
Startup.menu.repaint();
//Sets Timer For Cooldown
Timer t = new Timer();
t.schedule(new TimerTask() {
@Override
public void run() {
isComplete = true;
Startup.menu.repaint();
}
}, cooldown*1000);
}
public static boolean isReadyToSpawn()
{
return isComplete;
}
public static int getUnitCost()
{
if (COST <= 0) return -1;
else return COST;
}
}
| [
"Vortekdynamic@gmail.com"
] | Vortekdynamic@gmail.com |
d0b19fa1e2d0dd6991166320be84f67f05c1af6d | 8563e6e0da14d035bf8add0fdb9ebfc3e6a2bda1 | /src/main/java/com/myretail/entity/ErrorDetails.java | 92305cbc5de6618e0d786a030fce1456836f89fe | [] | no_license | phanibuddi9/MyRetailApp | 4ed663a6419f21f16ba260ef859cd6ea341fa772 | 3d6dd412e891cd59360af2e5fed6cb5c942bab48 | refs/heads/master | 2022-02-02T09:12:35.969260 | 2018-05-09T18:43:44 | 2018-05-09T18:43:44 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 880 | java | package com.myretail.entity;
import java.util.Date;
public class ErrorDetails {
private Date timestamp;
private String message;
private String details;
public ErrorDetails(Date timestamp, String message, String details) {
super();
this.timestamp = timestamp;
this.message = message;
this.details = details;
}
public Date getTimestamp() {
return timestamp;
}
public void setTimestamp(Date timestamp) {
this.timestamp = timestamp;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public String getDetails() {
return details;
}
public void setDetails(String details) {
this.details = details;
}
@Override
public String toString() {
return "ErrorDetails [timestamp=" + timestamp + ", message=" + message + ", details=" + details + "]";
}
}
| [
"niteshsinghrajput.mca@gmail.com"
] | niteshsinghrajput.mca@gmail.com |
e80b7c3306835698e03c66d620be196277dba150 | eb44e65b1468bbc220c11966518121f91981a6ca | /JavaAppiumAutomation/src/lib/ui/android/AndroidArticlePageObject.java | 8011ccf1b4b4519d2622b14fa35355070336e48c | [] | no_license | bondarenkodima/AvtoMobileTest | f6c186dcc1cd5782f2ee2c8bd7cd4c93d8d289bb | a55abba4eeeb42614be944d7f71f4ab7a5d773fe | refs/heads/master | 2020-04-16T23:43:35.048553 | 2019-03-17T15:15:20 | 2019-03-17T15:15:20 | 166,023,219 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,422 | java | package lib.ui.android;
import io.appium.java_client.AppiumDriver;
import lib.ui.ArticlePageObject;
public class AndroidArticlePageObject extends ArticlePageObject
{
static {
TITLE = "id:org.wikipedia:id/view_page_title_text";
FOOTER_ELEMENT = "xpath://*[@text='View page in browser']";
OPTIONS_BUTTON = "xpath://android.widget.ImageView[@content-desc='More options']";
OPTIONS_CHANGE_LANGUAGE_BUTTON = "xpath://*[@text= 'Change language']";
OPTIONS_SHARE_LINK_BUTTON = "xpath://*[@text= 'Share link']";
OPTIONS_ADD_TO_MY_LIST_BUTTON = "xpath://*[@text= 'Add to reading list']";
ADD_TO_MY_LIST_OVERLAY = "id:org.wikipedia:id/onboarding_button";
MY_LIST_NAME_INPUT = "id:org.wikipedia:id/text_input";
MY_LIST_OK_BUTTON = "xpath://*[@text='OK']";
CLOSE_ARTICLE_BUTTON = "xpath://android.widget.ImageButton[@content-desc='Navigate up']";
WAIT_ARTICLE_TITLE = "id:org.wikipedia:id/item_container";
ARTICLE_IN_MY_LIST = "xpath://*[@resource-id='org.wikipedia:id/page_list_item_container']//*[@text='scripting language']";
ARTICLE_TITLE = "xpath://*[@text='PHP']";
ARTICLE_DESCRIPTION = "xpath://*[@text='Scripting language']"; // дескрипшен
}
public AndroidArticlePageObject(AppiumDriver driver)
{
super(driver);
}
}
| [
"bondarenkodimay@gmail.com"
] | bondarenkodimay@gmail.com |
cdb82795991f709c014a00dbdad2b3e98ca3fe08 | c6a20ea2faf86869b9b9f69510c9843597fe1fe1 | /src/com/company/storables/Dragon.java | 4bdbd45e920f488d9e94a53706ad3fdd7301310d | [] | no_license | oaleksander/Lab7 | 39d41b0c1e34b5cfb928f41749bc1950e118bcc5 | 1ca18d05be5b7d31fef2e5692ca98b3ed470f9c8 | refs/heads/master | 2023-08-28T12:21:38.673589 | 2021-09-26T19:33:19 | 2021-09-26T19:33:19 | 352,652,258 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 10,511 | java | package com.company.storables;
import com.company.ui.User;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;
import java.util.Locale;
import java.util.Objects;
public class Dragon implements Comparable<Dragon> {
private long id; //Значение поля должно быть больше 0, Значение этого поля должно быть уникальным, Значение этого поля должно генерироваться автоматически
private String name; //Поле не может быть null, Строка не может быть пустой
private Coordinates coordinates; //Поле не может быть null
private java.util.Date creationDate; //Поле не может быть null, Значение этого поля должно генерироваться автоматически
private long age; //Значение поля должно быть больше 0
private String description; //Поле может быть null
private int weight; //Значение поля должно быть больше 0
private DragonType type; //Поле не может быть null
private DragonHead head;
private String owner;
/**
* Converts CSV format string to Dragon
*
* @param csvString CSV format string
* @throws IllegalArgumentException if CSV format string can't be parsed
*/
public Dragon(String csvString) throws IllegalArgumentException {
String[] splitString = csvString.split(",");
try {
if (splitString[0].chars().allMatch(Character::isWhitespace) || splitString[0].isEmpty())
setId(DragonUtils.getNewId());
else
try {
if (Long.parseLong(splitString[0]) == -1L)
setId(DragonUtils.getNewId());
setId(Long.parseLong(splitString[0]));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Can't parse Dragon id from " + splitString[0] + ".");
}
setName(splitString[1].replaceAll("\"", ""));
try {
setCoordinates(new Coordinates(splitString[2].chars().allMatch(Character::isWhitespace) || splitString[2].isEmpty() ? .0 : Double.parseDouble(splitString[2]), Long.parseLong(splitString[3])));
} catch (NumberFormatException | NullPointerException e) {
throw new IllegalArgumentException("Can't parse Dragon coordinates from " + splitString[2] + "," + splitString[3] + ".");
}
if (splitString[4].chars().allMatch(Character::isWhitespace) || splitString[4].isEmpty())
setCreationDate(new Date());
else
try {
setCreationDate(DateFormat.getDateInstance(DateFormat.SHORT, Locale.getDefault()).parse(splitString[4]));
} catch (ParseException e) {
throw new IllegalArgumentException("Can't parse creation date from " + splitString[4] + ".");
}
try {
setAge(Long.parseLong(splitString[5]));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Can't parse Dragon age from " + splitString[5] + ".");
}
setDescription(splitString[6].chars().allMatch(Character::isWhitespace) || splitString[6].isEmpty() ? "\"\"" : splitString[6].replaceAll("\"", ""));
try {
setWeight(Integer.parseInt(splitString[7]));
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Can't parse Dragon weight from " + splitString[7] + ".");
}
try {
setType(DragonType.valueOf(splitString[8]));
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Can't parse Dragon type from " + splitString[8] + ".");
}
setHead(new DragonHead(splitString[9]));
setOwner(splitString[10].chars().allMatch(Character::isWhitespace) || splitString[10].isEmpty() ? "\"\"" : splitString[10].replaceAll("\"", ""));
} catch (IndexOutOfBoundsException e) {
throw new IllegalArgumentException("Not enough arguments to parse Dragon (" + splitString.length + ").");
}
}
/**
* Default constructor
*/
public Dragon() {
}
/**
* Dragon constructor with fields
* @param id id
* @param name name
* @param coordinates coordinates
* @param creationDate creationDate
* @param age age
* @param description description
* @param weight weight
* @param type type
* @param head head
* @param owner owner
*/
public Dragon(long id, String name, Coordinates coordinates, Date creationDate, long age, String description, int weight, DragonType type, DragonHead head, String owner) {
setId(id);
setName(name);
setCoordinates(coordinates);
setCreationDate(creationDate);
setAge(age);
setDescription(description);
setWeight(weight);
setType(type);
setHead(head);
setOwner(owner);
}
/**
* Dragon == Object equals
*
* @param o Object
* @return true if equal
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Dragon dragon = (Dragon) o;
return id == dragon.id;
}
/**
* Dragon hashcode by id
*
* @return hashcode
*/
@Override
public int hashCode() {
return Objects.hash(id);
}
/**
* Dragon-to-Dragon comparator
*
* @param p Dragon
* @return >0 if this Dragon is older, <0 if this Dragon is younger, 0 if Dragons are of equal age
*/
@Override
public int compareTo(Dragon p) {
return (int) (this.getAge() - p.getAge());
}
/**
* Dragon ID getter
*
* @return ID
*/
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
/**
* Dragon ID getter
*
* @return ID
*/
public String getName() {
return name;
}
/**
* Dragon name setter
*
* @param name name
*/
public void setName(String name) {
this.name = name;
}
/**
* Dragon ID getter
*
* @return ID
*/
public Coordinates getCoordinates() {
return coordinates;
}
/**
* Dragon coordinates setter
*
* @param coordinates coordinates
*/
public void setCoordinates(Coordinates coordinates) {
this.coordinates = coordinates;
}
/**
* Dragon creation date getter
*
* @return creation date
*/
public Date getCreationDate() {
return creationDate;
}
/**
* Dragon creation date setter
*
* @param creationDate creationDate
*/
public void setCreationDate(Date creationDate) {
this.creationDate = creationDate;
}
/**
* Dragon age getter
*
* @return age
*/
public long getAge() {
return age;
}
/**
* Dragon age setter
*
* @param age age
* @throws IllegalArgumentException if age is invalid
*/
public void setAge(long age) throws IllegalArgumentException {
if (age < 0)
throw new IllegalArgumentException("Age can't be less than 0");
this.age = age;
}
/**
* Dragon description getter
*
* @return description
*/
public String getDescription() {
return description;
}
/**
* Dragon description setter
*
* @param description description
*/
public void setDescription(String description) {
this.description = description;
}
/**
* Dragon ID getter
*
* @return ID
*/
public int getWeight() {
return weight;
}
/**
* Dragon weight setter
*
* @param weight weight
* @throws IllegalArgumentException if weight is illegal
*/
public void setWeight(int weight) throws IllegalArgumentException {
if (weight < 0)
throw new IllegalArgumentException("Weight can't be less than 0");
this.weight = weight;
}
/**
* Dragon ID getter
*
* @return ID
*/
public DragonType getType() {
return type;
}
/**
* Dragon type setter
*
* @param type dragon type
*/
public void setType(DragonType type) {
this.type = type;
}
/**
* Dragon ID getter
*
* @return ID
*/
public DragonHead getHead() {
return head;
}
/**
* Dragon head setter
*
* @param head dragon head
*/
public void setHead(DragonHead head) {
this.head = head;
}
/**
* Dragon owner getter
*
* @return owner
*/
public String getOwner() {
return owner;
}
/**
* Dragon owner setter
*
* @param owner new owner;
*/
public void setOwner(String owner) {
this.owner = owner;
}
/**
* Dragon - to - string converter
*
* @return dragon string
*/
@Override
public String toString() {
return "Dragon: " +
"id=" + id +
", name='" + name + '\'' +
", coordinates=" + coordinates +
", creationDate=" + creationDate +
", age=" + age +
", description='" + description + '\'' +
", weight=" + weight +
", type=" + type +
", head=" + head +
", owner=" + owner;
}
/**
* Converts Dragon to CSV string
*
* @return CSV string
*/
public String toCsvString() {
return getId() + ",\"" + getName() + "\"," + getCoordinates().getX() + "," + getCoordinates().getY() + "," + DateFormat.getDateInstance(DateFormat.SHORT).format(getCreationDate()) + "," + getAge() + ",\"" + (getDescription() == null ? "" : getDescription()) + "\"," + getWeight() + "," + getType().getLabel() + "," + getHead().getEyesCount() + ",\"" + getOwner() + "\"";
}
} | [
"medvedev.asm@outlook.com"
] | medvedev.asm@outlook.com |
7826713bd02de59b4153a3a7717fabaa1f7d8a51 | 3b33dc354b74fe72a00defa562c82c09659c14b1 | /src/com/study/object_oriented_design/ood2/ParkingLotLaicode/Vehicles/Vehicle.java | cb86eb3dfedc4b70ca721893ac7ed8b9b883c60b | [] | no_license | 98ning/LaiCode-2 | 9355de917bbe70c8ea8010267f3af78716e1ffa5 | 178ad24b92e14e0d38594481cb9ed27582bcd8c7 | refs/heads/master | 2023-07-03T23:20:55.477698 | 2021-08-09T04:51:30 | 2021-08-09T04:51:30 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 553 | java | package com.study.object_oriented_design.ood2.ParkingLotLaicode.Vehicles;
public abstract class Vehicle {
public final String plate;
public abstract VehicleSize getSize();
Vehicle(String plate) {
this.plate = plate;
}
}
class Truck extends Vehicle {
Truck(String plate) {
super(plate);
}
@Override
public VehicleSize getSize() {
return VehicleSize.Compact;
}
}
class Car extends Vehicle {
Car(String plate) {
super(plate);
}
@Override
public VehicleSize getSize() {
return VehicleSize.Compact;
}
}
| [
"Ma_Yaowei@outlook.com"
] | Ma_Yaowei@outlook.com |
3255e7f1f9444c557e926f35c8092f7066ab8a77 | d67b6f7a9d026cf5cceb12e887734c0d7a9f16eb | /src/main/java/nk/gk/wyl/semanticsearch/util/IkUtil.java | afc316df922daea80e82675a231038342c95f74c | [] | no_license | zhangshuailing/semantic-search | 3aeaf605f7b96c516734566fc9db93aa060848b1 | 2e6a51fa308bff1b2b57eb6342858fa7131733ec | refs/heads/main | 2023-02-25T10:35:53.084908 | 2021-01-28T13:19:34 | 2021-01-28T13:19:34 | 331,163,717 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,212 | java | package nk.gk.wyl.semanticsearch.util;
import org.apdplat.word.WordSegmenter;
import org.apdplat.word.segmentation.Word;
import java.util.ArrayList;
import java.util.List;
public class IkUtil {
private static WordSegmenter wordSegmenter =null;
public static WordSegmenter getWordSegmenter() {
return wordSegmenter;
}
public static void setWordSegmenter(WordSegmenter wordSegmenter) {
IkUtil.wordSegmenter = wordSegmenter;
}
public IkUtil(){
WordSegmenter wordSegmenter = new WordSegmenter();
wordSegmenter.seg("text");
setWordSegmenter(wordSegmenter);
}
public static void main(String[] args) {
String text = "姚明有多高？";
try {
System.out.println(getStringList(text));
} catch (Exception e) {
e.printStackTrace();
}
}
public static List<String> getStringList(String text) throws Exception{
List<Word> words = wordSegmenter.seg(text);
List<String> result = new ArrayList<>();
for (int i = 0; i < words.size(); i++) {
Word word = words.get(i);
result.add(word.toString());
}
return result;
}
}
| [
"zhangshuailing@golaxy.cn"
] | zhangshuailing@golaxy.cn |
0dbe98a274d64c8779acb16bad912ea541d9ffe8 | f9c621755f3b3e0786055c78738beff8885bc3b6 | /java210208/src/athread/talk2/TomatoServer.java | a6fc86af719a49f15377b46211c7002c4f1b2bc1 | [] | no_license | dnguddl9436/java210208-1 | b89a7d704450c33acbdef3aa01120166c24fca67 | b4e7089b5254ed1decd8022c33211229d66933fe | refs/heads/main | 2023-04-16T08:37:01.842605 | 2021-04-13T06:23:08 | 2021-04-13T06:23:08 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 4,404 | java | package athread.talk2;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Calendar;
import java.util.List;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import athread.talk1.TalkServerThread;
public class TomatoServer extends JFrame implements Runnable{
//사용자가 접속을 해올 때 마다(입장) 새로 객체를 생성해야 함.- 왜냐하면 서로 다른 사람이니까 그사람의 소켓, 그사람의 ois, 그만의 oos
TomatoServerThread tst = null;
//Vector로 선언하지 않는 이유는 다형성을 말하기 위함.
//내안에 강감찬 스레드 관리, 이순신 스레드 관리
List<TomatoServerThread> globalList = null;
List<Room> roomList = null;
ServerSocket server = null;
Socket socket = null;
JTextArea jta_log = new JTextArea(10,30);
JScrollPane jsp_log = new JScrollPane(jta_log
,JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED
,JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
JPanel jp_north = new JPanel();
JButton jbtn_log = new JButton("로그저장");
String logPath = "src\\athread\\talk2\\";
//서버소켓과 클라이언트측 소켓을 연결하기
@Override
public void run() {
//서버에 접속해온 클라이언트 스레드 정보를 관리할 벡터 생성하기
globalList = new Vector<>();
boolean isStop = false;
try {
server = new ServerSocket(3002);
jta_log.append("Server Ready.........\n");
while(!isStop) {
socket = server.accept();
jta_log.append("client info:"+socket+"\n");//유저의 정보
tst = new TomatoServerThread(this);//TST
tst.start();//run호출
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void initDisplay() {
jbtn_log.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
Object obj = e.getSource();
if(obj==jbtn_log) {
String fileName = "log_"+setTimer()+".txt";
System.out.println(fileName);//log_2020-03-13.txt
try {
//자바는 모든 기능 사물 들을 클래스로 설계하도록 유도한다.
//파일명을 클래스로 만들어주는 API가 있다. -File
File f = new File(logPath+fileName);
//파일명만 생성될 뿐 내용까지 만들어주지는 않는다.
//내용부분을 담는 별도의 클래스가 필요하다.
PrintWriter pw =
new PrintWriter(
new BufferedWriter(//필터클래스-카메라 필터
new FileWriter(f.getAbsolutePath())));
//io패키지에는 단독으로 파일을 컨트롤할 수 있는 클래스가 있고
//그 클래스에 연결해서 사용하는 필터 클래스가 존재함.(기능을 향상해줌)
pw.write(jta_log.getText());
pw.close();//사용한 입출력 클래스는 반드시 닫아줌.
} catch (Exception e2) {
//예외가 발생했을 때 출력함.
//예외가 발생하지 않으면 실행이 안됨.
System.out.println(e2.toString());
}
}
}
});
jp_north.setLayout(new FlowLayout(FlowLayout.LEFT));
jta_log.setBackground(Color.orange);
jp_north.add(jbtn_log);
this.add("North",jp_north);
this.add("Center",jsp_log);
this.setSize(500, 400);
this.setVisible(true);
}
public static void main(String args[]) {
TomatoServer ts = new TomatoServer();
ts.initDisplay();
Thread th = new Thread(ts);
th.start();
}
/*******************************************************
* 시스템의 오늘 날짜 정보 가져오기
* @param 해당사항 없음.
* @return 2020-03-13
******************************************************/
public String setTimer() {
Calendar cal = Calendar.getInstance();
int yyyy = cal.get(Calendar.YEAR);
int mm = cal.get(Calendar.MONTH)+1;
int day = cal.get(Calendar.DAY_OF_MONTH);
return yyyy+"-"+
(mm < 10 ? "0"+mm:""+mm)+"-"+
(day < 10 ? "0"+day:""+day);
}////////////////end of setTimer
}
| [
"slalom0914@gmail.com"
] | slalom0914@gmail.com |
f2e1bd52790b31d66ba7550dc9ea2bd1f7a32122 | 127a610e64277a8ba898c2203bf9cb6bca05afc0 | /src/main/java/kr/happyjob/study/sample/service/SampleComnCodService.java | e8629002d30ca0b752b7b93280c3f5eeb92bd205 | [] | no_license | SCMPJ/scm_basecode | 3d209f1d1b39515a26fe9bab5c977e55a3953533 | 7802b500e604839ca2ba70322a04c83e90d74309 | refs/heads/main | 2023-05-30T20:18:04.239875 | 2021-06-07T02:57:20 | 2021-06-07T02:57:20 | 364,464,861 | 0 | 5 | null | 2021-06-07T02:57:20 | 2021-05-05T04:53:15 | JavaScript | UTF-8 | Java | false | false | 1,770 | java | package kr.happyjob.study.sample.service;
import java.util.List;
import java.util.Map;
import kr.happyjob.study.system.model.ComnCodUtilModel;
import kr.happyjob.study.system.model.ComnDtlCodModel;
import kr.happyjob.study.system.model.ComnGrpCodModel;
public interface SampleComnCodService {
/** 그룹코드 목록 조회 */
public List<ComnGrpCodModel> gouppcodelist(Map<String, Object> paramMap) throws Exception;
/** 그룹코드 목록 카운트 조회 */
public int gouppcodecount(Map<String, Object> paramMap) throws Exception;
/** 상세코드 목록 조회 */
public List<ComnDtlCodModel> detailcodelist(Map<String, Object> paramMap) throws Exception;
/** 상세코드 목록 카운트 조회 */
public int detailcodecount(Map<String, Object> paramMap) throws Exception;
/** 그룹코드 한건 조회 */
public ComnGrpCodModel selectgroupcode(Map<String, Object> paramMap) throws Exception;
/** 그룹코드 등록 */
public void insertgroupcode(Map<String, Object> paramMap) throws Exception;
/** 그룹코드 수정 */
public void updategroupcode(Map<String, Object> paramMap) throws Exception;
/** 그룹코드 삭제 */
public void deletegroupcode(Map<String, Object> paramMap) throws Exception;
/** 상세코드 한건 조회 */
public ComnDtlCodModel selectdetailcode(Map<String, Object> paramMap) throws Exception;
/** 상세코드 등록 */
public void insertdetailcode(Map<String, Object> paramMap) throws Exception;
/** 상세코드 수정 */
public void updatedetailcode(Map<String, Object> paramMap) throws Exception;
/** 상세코드 삭제 */
public void deletedetailcode(Map<String, Object> paramMap) throws Exception;
} | [
"sangsu9701@naver.com"
] | sangsu9701@naver.com |
b43aef8cdfdf17113e87259a7d32520873242b8e | e40cbdba721943ac5596e98a15b4dd9a51204079 | /core/src/maps/EasyPortal.java | 4e5258641e7ebcf87eb75896e598410e26ab386e | [] | no_license | Lotrius/Wave | edc5af54065e8ee38dd52f08510193143fbba0cb | 870580ba1ac2347bf20d48d4f28116edc7a9fd1b | refs/heads/master | 2020-03-19T19:27:31.894836 | 2018-10-09T18:03:32 | 2018-10-09T18:03:32 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,050 | java | package maps;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input.Keys;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import characters.Player;
import characters.Warrior;
import wave.Wave;
public class EasyPortal extends InGameScreen {
private Wave game;
public EasyPortal(Wave game, Player player) {
// Set up parameters
this.game = game;
this.player = player;
// Create new tiled map and get dimensions
tiledMap = new TmxMapLoader().load("map/EasyPortal/easy_portal.tmx");
mapWH = getMapWH(tiledMap);
mapRight = mapTop = mapWH * RATIO;
// Rrrrrrrrrenderer
renderer = new OrthogonalTiledMapRenderer(tiledMap, RATIO);
// Starting position
x = 550;
y = 600;
// Camera position
cam.position.x = x;
cam.position.y = y;
}
protected void checkCollision() {
// Call checkCollision() in super class
//super.checkCollision(collisionObjects);
}
public void changeMap() {
// If the player tries to take the road to the portal area, dispose of current screen
// and load portal area
if (Gdx.input.isKeyPressed(Keys.K)) {
this.dispose();
game.setScreen(new PortalArea1(game, player));
}
}
@Override
public void render(float delta) {
// Exit if ESC pressed
if (Gdx.input.isKeyPressed(Keys.ESCAPE)) {
Gdx.app.exit();
}
// Set up camera and view
game.batch.setProjectionMatrix(cam.combined);
renderer.setView(cam);
renderer.render();
// Check for collisions or map changes
checkCollision();
changeMap();
// Call the superclass render function to do movement
super.render(delta);
player.setX(x);
player.setY(y);
player.getBody().setX(x);
player.getBody().setY(y);
// Draw player and constantly update
game.batch.begin();
game.batch.draw(player.getTexture(), player.getX(), player.getY(),
PLAYER_WIDTH, PLAYER_HEIGHT);
game.batch.end();
}
@Override
public void dispose() {
// Destroy everything
// music.dispose();
// grass.dispose()
}
}
| [
"user.email"
] | user.email |
9a6a39efb63274dedf202f35cc0a097f907c3c6d | 1d928c3f90d4a0a9a3919a804597aa0a4aab19a3 | /java/neo4j/2015/8/BigLabelStoreGenerator.java | 36d180acfc1abea0ffaf1977405d530ab0b7c188 | [] | no_license | rosoareslv/SED99 | d8b2ff5811e7f0ffc59be066a5a0349a92cbb845 | a062c118f12b93172e31e8ca115ce3f871b64461 | refs/heads/main | 2023-02-22T21:59:02.703005 | 2021-01-28T19:40:51 | 2021-01-28T19:40:51 | 306,497,459 | 1 | 1 | null | 2020-11-24T20:56:18 | 2020-10-23T01:18:07 | null | UTF-8 | Java | false | false | 5,414 | java | /*
* Copyright (c) 2002-2015 "Neo Technology,"
* Network Engine for Objects in Lund AB [http://neotechnology.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.neo4j.shell;
import java.io.File;
import java.util.Arrays;
import java.util.Random;
import org.neo4j.graphdb.DynamicLabel;
import org.neo4j.graphdb.GraphDatabaseService;
import org.neo4j.graphdb.Label;
import org.neo4j.graphdb.Transaction;
import org.neo4j.graphdb.factory.GraphDatabaseBuilder;
import org.neo4j.graphdb.factory.GraphDatabaseFactory;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.String.format;
/**
* Builds a store in the path at $GRAPH_DB of $NUM_NODES nodes, where each node has at most
* $NUM_LABELS randomly selected labels.
*
* keep_logical_logs=false
* neostore.nodestore.db.mapped_memory=28000M
* neostore.nodestore.db.labels.mapped_memory=14000M
*
* MAVEN_OPTS="-server -Xmx10g -Xms10G -Xmn4G -XX:MaxDirectMemorySize=35G"
* mvn exec:java -Dexec.mainClass="org.neo4j.shell.BigLabelStoreGenerator"
*/
public class BigLabelStoreGenerator
{
private static Random random = new Random();
public static void main(String[] args)
{
long batchSize = parseLong( withDefault( System.getenv().get( "BATCH_SIZE" ), "100000" ) );
long numNodes = parseLong( withDefault( System.getenv( "NUM_NODES" ), "1000000" ) );
int numLabels = parseInt( withDefault( System.getenv( "NUM_LABELS" ), "5" ) );
String graphDbPath = System.getenv( "GRAPH_DB" );
System.out.println( format( "# BATCH_SIZE: %d, NUM_NODES: %d, NUM_LABELS: %d, GRAPH_DB: '%s'",
batchSize, numNodes, numLabels, graphDbPath ) );
GraphDatabaseService graph = createGraphDatabaseService( graphDbPath );
Label[] labels = createLabels( numLabels );
int[] statistics = new int[numLabels];
assert( numLabels == labels.length );
long labelings = 0;
long start = System.currentTimeMillis();
try {
for ( long l = 0; l < numNodes; l += batchSize )
{
long batchStart = System.currentTimeMillis();
try ( Transaction tx = graph.beginTx() )
{
for ( long m = 0; m < batchSize; m++ )
{
Label[] selectedLabels = pickRandomLabels( labels );
for (int i = 0; i < selectedLabels.length; i++)
{
statistics[i]++;
}
labelings += selectedLabels.length;
graph.createNode( selectedLabels );
}
tx.success();
}
long batchDuration = System.currentTimeMillis() - batchStart;
System.out.println( format( "nodes: %d, ratio: %d, labelings: %d, duration: %d, label statistics: %s",
l, l*100/numNodes, labelings, batchDuration, Arrays.toString( statistics ) ) );
}
}
finally
{
graph.shutdown();
}
long duration = System.currentTimeMillis() - start;
System.out.println( format( "nodes: %d, ratio: %d, labelings: %d, duration: %d", numNodes, 100, labelings, duration ) );
}
private static GraphDatabaseService createGraphDatabaseService( String graphDbPath )
{
GraphDatabaseFactory factory = new GraphDatabaseFactory();
GraphDatabaseBuilder graphBuilder = factory.newEmbeddedDatabaseBuilder( graphDbPath );
File propertiesFile = new File( graphDbPath, "neo4j.properties");
if ( propertiesFile.exists() && propertiesFile.isFile() && propertiesFile.canRead() )
{
System.out.println( format( "# Loading properties file '%s'", propertiesFile.getAbsolutePath() ) );
graphBuilder.loadPropertiesFromFile( propertiesFile.getAbsolutePath() );
}
else
{
System.out.println( format( "# No properties file found at '%s'", propertiesFile.getAbsolutePath() ) );
}
return graphBuilder.newGraphDatabase();
}
private static String withDefault( String value, String defaultValue )
{
return null == value ? defaultValue : value;
}
private static Label[] pickRandomLabels( Label[] labels )
{
return Arrays.copyOf( labels, 1 + random.nextInt( labels.length ) );
}
private static Label[] createLabels( int numLabels )
{
Label[] labels = new DynamicLabel[numLabels];
for ( int i = 0; i < numLabels; i++ )
{
labels[i] = DynamicLabel.label( format( "LABEL_%d", i ) );
}
return labels;
}
}
| [
"rodrigosoaresilva@gmail.com"
] | rodrigosoaresilva@gmail.com |
ac63eb8893eecfe801dc72c05700c76000bcea64 | 89dc077c14f5122d25705ed9c3f62b9fab6d3d57 | /src/intexsoftBookLibrary/dao/MySqlDAOFactory.java | 70ab81fd06f2de695c8cde7dc47a211ef4335400 | [] | no_license | SasimovichAndrey/intexsoftBooklibrary | eca9ef90825a379a27c7570697b9292ea6fe8cc0 | e077281c6b6b7693256d840940c8e4f0dfc657dc | refs/heads/master | 2016-09-06T18:59:59.045267 | 2013-11-05T12:01:06 | 2013-11-05T12:01:06 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 356 | java | package intexsoftBookLibrary.dao;
import intexsoftBookLibrary.dao.mysql.MySqlBookDAO;
import intexsoftBookLibrary.dao.mysql.MySqlLibraryDAO;
public class MySqlDAOFactory extends DAOFactory {
@Override
public IBookDAO getBookDAO() {
return new MySqlBookDAO();
}
@Override
public ILibraryDAO getLibraryDAO() {
return new MySqlLibraryDAO();
}
}
| [
"ballack.tyta@gmail.com"
] | ballack.tyta@gmail.com |
0666b292c93a3fcc8a0e1c38d09ee77bbb7eeff8 | c1eee50fbb37bc5b2b5e30a2550865182cdf205c | /ANDROID/HelloAndroid/app/src/androidTest/java/com/hyeran/android/helloandroid/ExampleInstrumentedTest.java | 3e2ca595a5ecc72e1915d74b28a82983651cf2cc | [] | no_license | gogog123/java-android-study | 61caae559803ca5959607560be5d3e065c9844e6 | 58f80a21a9235b7d79422050e897881b52575f1d | refs/heads/master | 2022-03-26T10:38:05.742752 | 2020-01-13T17:48:05 | 2020-01-13T17:48:05 | null | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 746 | java | package com.hyeran.android.helloandroid;
import android.content.Context;
import android.support.test.InstrumentationRegistry;
import android.support.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.junit.Assert.*;
/**
* Instrumented test, which will execute on an Android device.
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
@RunWith(AndroidJUnit4.class)
public class ExampleInstrumentedTest {
@Test
public void useAppContext() {
// Context of the app under test.
Context appContext = InstrumentationRegistry.getTargetContext();
assertEquals("com.hyeran.android.helloandroid", appContext.getPackageName());
}
}
| [
"hyebaragi__@naver.com"
] | hyebaragi__@naver.com |
2b9b310e8e349045191918f78ff4fca9b5f4e08a | 8ffa9c5e3e73bafbdf3fe822a91e245140b0baa6 | /src/com/IOliu/File_test.java | c537578c7b3e6399d65a4a041fd396bcf956a580 | [] | no_license | 15503400097/java | de60b661cebaf5564d7ab5f7095b79d679049c18 | 76ffc743411a3e8b7be8b5da43b5ae65aa34bff5 | refs/heads/master | 2020-11-25T18:13:58.018020 | 2019-12-18T07:48:14 | 2019-12-18T07:48:14 | 228,788,853 | 0 | 0 | null | 2020-10-13T18:18:03 | 2019-12-18T08:02:23 | Java | UTF-8 | Java | false | false | 878 | java | package com.IOliu;
import java.io.File;
import java.util.Date;
import java.text.SimpleDateFormat;
public class File_test {
public static void main(String[] args) {
File file=new File("d:\\wq\\w.txt");
System.out.println("文件名是:"+file.getName());
System.out.println("文件的相对路径是："+file.getPath());
System.out.println("文件的绝对路径是："+file.getAbsolutePath());
System.out.println("文件的父路径是:"+file.getParent());
System.out.println(file.canRead()?"文件可读":"文件不可读");
System.out.println(file.canWrite()?"文件可写":"文件不可写");
System.out.println(file.isFile()?"是一个文件":"是一个目录");
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
System.out.println("最后修改时间是"+sdf.format(new Date(file.lastModified())));
}
}
| [
"1527814421@qq.cn"
] | 1527814421@qq.cn |
f6ebe64005abe459a9185da5f3105e71e9019824 | fa90e85911f48215fb72c3daf2bac5bfee9fde27 | /app/src/main/java/com/simtoonsoftware/taxthegame/ShopActivity.java | 64038f1d230f20172166cc85e16176c63249228d | [] | no_license | ongakken/TaxTheGame | 28b93759529c468b671b4c71d0558c4b4884fa48 | 539ee25879d1069dd9ac6c04cb90fe69970c8004 | refs/heads/master | 2023-04-23T15:06:02.110258 | 2021-05-16T14:48:06 | 2021-05-16T14:48:06 | 186,877,905 | 0 | 0 | null | 2021-05-16T14:48:07 | 2019-05-15T17:57:30 | Java | UTF-8 | Java | false | false | 92 | java | package com.simtoonsoftware.taxthegame;
public class ShopActivity extends MainActivity {
}
| [
"simon.slamka@adlerka.sk"
] | simon.slamka@adlerka.sk |
393721b8315277223c7286656572c19f1308a242 | 6bbab2bd7dce6c64ed0f33e7933cfdde9c0e3367 | /src/main/java/com/jacob2/com/ComFailException.java | a7b0f03831358f67a6bd036586c5f1a778b22e33 | [] | no_license | wangkm/zeroDoc | 46ee2d85e24db66b22ab589fa655e042409f57fd | e3052aeb97c8f8d22667b4b96bbddf0fd3d555c6 | refs/heads/master | 2020-05-23T10:07:50.734132 | 2019-05-15T00:12:21 | 2019-05-15T00:12:21 | 186,718,708 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,192 | java | /*
* Copyright (c) 1999-2004 Sourceforge JACOB Project.
* All rights reserved. Originator: Dan Adler (http://danadler.com).
* Get more information about JACOB at http://sourceforge.net/projects/jacob-project
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
package com.jacob2.com;
/**
* COM Fail Exception class raised when there is a problem
*/
public class ComFailException extends ComException {
/**
* eclipse generated to get rid of a wanring
*/
private static final long serialVersionUID = -266047261992987700L;
/**
* Constructor
*
* @param hrNew
*/
public ComFailException(int hrNew) {
super(hrNew);
}
/**
* Constructor
*
* @param hrNew
* @param message
*/
public ComFailException(int hrNew, String message) {
super(hrNew, message);
}
/**
* @param hrNew
* @param source
* @param helpFile
* @param helpContext
*/
public ComFailException(int hrNew, String source, String helpFile,
int helpContext) {
super(hrNew, source, helpFile, helpContext);
}
/**
* Constructor
*
* @param hrNew
* @param description
* @param source
* @param helpFile
* @param helpContext
*/
public ComFailException(int hrNew, String description, String source,
String helpFile, int helpContext) {
super(hrNew, description, source, helpFile, helpContext);
}
/**
* No argument Constructor
*/
public ComFailException() {
super();
}
/**
* @param message
*/
public ComFailException(String message) {
super(message);
}
} | [
"wkm@outlook.com"
] | wkm@outlook.com |
b1df30dda910da83a6408338f46bfa0bc6497479 | 252ca25cbd1b5aacf24e2f6dee14622624287ef0 | /NewsSys/src/com/my/servlet/back/BNewslistSvl.java | fdcfe25d41d5d8bade1bb39fbe1a1bab11d18e91 | [] | no_license | Edenwds/icss_practice | c60c6289844e3629a4abd68f9b134fd1189d439a | 48cc2f1d3793165c006c23359ee274eece382769 | refs/heads/master | 2022-02-21T17:33:16.885142 | 2019-07-26T07:20:03 | 2019-07-26T07:20:03 | 103,266,772 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,811 | java | package com.my.servlet.back;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.my.biz.NewsBiz;
import com.my.dto.TurnPage;
import com.my.entity.TCategory;
import com.my.entity.TNews;
import com.my.util.GetAllCategory;
import com.my.util.Log;
/**
* Servlet implementation class BNewslistSvl
*/
public class BNewslistSvl extends HttpServlet {
private static final long serialVersionUID = 1L;
/**
* @see HttpServlet#HttpServlet()
*/
public BNewslistSvl() {
super();
// TODO Auto-generated constructor stub
}
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
doPost(req,resp);
}
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
String ntype = request.getParameter("ntype");
String keyword = request.getParameter("keyword");
String beginDate = request.getParameter("beginDate");
String endDate = request.getParameter("endDate");
Date bDate = null, eDate = null;
NewsBiz biz = new NewsBiz();
SimpleDateFormat format = new SimpleDateFormat("MM/dd/yyyy");
try {
if(beginDate != null && !beginDate.trim().equals("")){
bDate = format.parse(beginDate);
}
if(endDate != null && !endDate.trim().equals("")){
eDate = format.parse(endDate);
}
String page = request.getParameter("page");
int initpage = 1;
if(page != null){
initpage = Integer.parseInt(page);
if(initpage < 1)
initpage = 1;
}
TurnPage tp = new TurnPage();
tp.pageno = initpage;
List<TNews> newslist = biz.getBackAllNews(tp, ntype, keyword, bDate, eDate);
request.setAttribute("newslist", newslist);
request.setAttribute("ntype", ntype);
request.setAttribute("keyword", keyword);
request.setAttribute("beginDate", beginDate);
request.setAttribute("endDate", endDate);
request.setAttribute("pageno", tp.pageno);
request.setAttribute("allRows", tp.allRows);
request.setAttribute("allPages", tp.allPages);
//每次翻页都要得到所有的类型
List<TCategory> allcg = null;
allcg = GetAllCategory.getall();
request.setAttribute("allcg", allcg);
request.getRequestDispatcher("/WEB-INF/jsp/back/bnewslist.jsp").forward(request, response);
} catch (ParseException e) {
e.printStackTrace();
Log.logger.error(e.getMessage());
} catch (Exception e) {
e.printStackTrace();
Log.logger.error(e.getMessage());
}
}
}
| [
"1466809510@qq.com"
] | 1466809510@qq.com |
94606b46e3d3b3fccaad7ce25f392ac6f6888bdb | 0d4c6da7f19c3cce755541dc577f339f653798c1 | /app/src/main/java/ricky/easybrowser/utils/CollectionUtils.java | 2868dabac52f285996f7493fce331a806b1c8613 | [] | no_license | ricky9090/EasyBrowser | 7c0694c18b9637162de40af6f9d3e01ebf4f8f09 | b1782a052e46641fa52b1f14aa53a69b5201a39d | refs/heads/master | 2022-02-07T09:35:46.675922 | 2022-02-01T03:18:42 | 2022-02-01T03:18:42 | 180,734,164 | 44 | 9 | null | null | null | null | UTF-8 | Java | false | false | 328 | java | package ricky.easybrowser.utils;
import java.util.Collection;
public class CollectionUtils {
public static boolean isEmpty(Collection collection) {
return collection == null || collection.isEmpty();
}
public static boolean isNotEmpty(Collection collection) {
return !isEmpty(collection);
}
}
| [
"unreal_star13@126.com"
] | unreal_star13@126.com |
2a85819162eb428d629833bf51e7a51d6b0242a3 | 7681ad3b826ca0ddc8f36b62050d60fecaa78ca5 | /greed/text-justify.java | 7277f0974c9b319a138d943831ce68ae2ff45c3c | [] | no_license | anthonychung14/algorithms | 5b52f61cb5e16ba41cadbaeaa32c273473d4514f | 6b0daa0e6165fe355d0d68b56b0ba720045fe5fc | refs/heads/master | 2021-01-10T13:51:46.782797 | 2017-12-19T05:26:33 | 2017-12-19T05:26:33 | 55,302,667 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 2,716 | java | // Given an array of words and a length L,
// format the text such that each line has exactly L characters
// and is fully (left and right) justified.
// You should pack your words in a greedy approach;
// that is, pack as many words as you can in each line.
// Pad extra spaces ' ' when necessary so that each line
// has exactly L characters.
// Extra spaces between words
// should be distributed as evenly as possible.
// If the number of spaces on a line do not divide evenly between words,
// the empty slots on the left will be assigned more spaces
// than the slots on the right.
// For the last line of text, it should be left justified
// and no extra space is inserted between words.
public List<String> fullJustify(String[] words, int maxWidth) {
List<String> result = new ArrayList<String>();
if(words==null || words.length==0){
return result;
}
int count = 0;
int last = 0;
ArrayList<String> list = new ArrayList<String>();
// for each of the words in the input
for(int i=0; i<words.length; i++){
// increment our count of chars by currWord length
count = count + words[i].length();
// at first, last is 0, so if adding curr word puts us over
if(count+i-last>maxWidth){
// calc difference between the count
int wordsLen = count-words[i].length();
int spaceLen = maxWidth-wordsLen;
int eachLen = 1;
int extraLen = 0;
if(i-last-1>0){
eachLen = spaceLen/(i-last-1);
extraLen = spaceLen%(i-last-1);
}
StringBuilder sb = new StringBuilder();
for(int k=last; k<i-1; k++){
sb.append(words[k]);
int ce = 0;
while(ce<eachLen){
sb.append(" ");
ce++;
}
if(extraLen>0){
sb.append(" ");
extraLen--;
}
}
sb.append(words[i-1]);//last words in the line
//if only one word in this line, need to fill left with space
while(sb.length()<maxWidth){
sb.append(" ");
}
result.add(sb.toString());
last = i;
count=words[i].length();
}
}
int lastLen = 0;
StringBuilder sb = new StringBuilder();
for(int i=last; i<words.length-1; i++){
count = count+words[i].length();
sb.append(words[i]+" ");
}
sb.append(words[words.length-1]);
int d=0;
while(sb.length()<maxWidth){
sb.append(" ");
}
result.add(sb.toString());
return result;
}
| [
"anthonychung14@gmail.com"
] | anthonychung14@gmail.com |
7abedfcb004009ff536953d1458900f2ed15929f | 0f07875056ac8f6429f554b14a73b351cf216940 | /hacks/PalincaPalincie/src/java/ro/dracula/business/order/control/XtremeIngredientProvider.java | 1cefce409f50e62b1f93bb674cd5aea53c4c3f12 | [] | no_license | dlee0113/java_ee_patterns_and_best_practices | b40b541d46799b634b52ffc5a31daf1e08236cc5 | 195a8ddf73e656d9acb21293141d6b38a47d0069 | refs/heads/master | 2020-06-30T03:26:52.852948 | 2015-04-01T12:35:15 | 2015-04-01T12:35:15 | 33,245,536 | 15 | 12 | null | null | null | null | UTF-8 | Java | false | false | 378 | java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package ro.dracula.business.order.control;
/**
*
* @author abien
*/
//@DrinkingLevel(DrinkingLevel.Level.ADVANCED)
public class XtremeIngredientProvider implements IngredientsProvider {
@Override
public String getIngredients() {
return "80% alc";
}
}
| [
"dlee0113@gmail.com"
] | dlee0113@gmail.com |
6426cf5bef7f3c7a67e080441202eefc0748e15b | d44948644566b54ddaee31de176120e5cb882c37 | /src/main/java/com/enisfr/recipebook/repositories/UnitOfMeasureRepository.java | eada7b66c1a9e78753a85cbcf55e5ec6fc82c60b | [] | no_license | enisfr/recipe-book | 95c3a8040081b4aaa161ec57b660a6c33187810d | a0063b8b818c95aef3f990a2b91d75ac54bfb4a0 | refs/heads/master | 2023-02-25T14:43:57.576714 | 2021-02-03T21:06:47 | 2021-02-03T21:06:47 | 332,537,749 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 341 | java | package com.enisfr.recipebook.repositories;
import com.enisfr.recipebook.domain.UnitOfMeasure;
import org.springframework.data.repository.CrudRepository;
import java.util.Optional;
public interface UnitOfMeasureRepository extends CrudRepository<UnitOfMeasure, Long> {
Optional<UnitOfMeasure> findByDescription(String description);
}
| [
"enisfurkane@gmail.com"
] | enisfurkane@gmail.com |
2d61a3b1340931d313172cc90585a892e4a9844b | 320f42d46e43abf9c6e805da5fcb08b9d21e7390 | /app/src/test/java/com/work/fargments/ExampleUnitTest.java | 00823836b0b21f43e64d27f28d26c853f04f1d64 | [] | no_license | Bvekv1/Fargments | 6b01b110361e0519cb5bd1fd49c8265288ec02c0 | d0ef86327550386461c5234709de224732958c37 | refs/heads/master | 2020-09-05T16:46:28.795338 | 2019-11-09T06:24:39 | 2019-11-09T06:24:39 | 220,159,962 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 379 | java | package com.work.fargments;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Example local unit test, which will execute on the development machine (host).
*
* @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
*/
public class ExampleUnitTest {
@Test
public void addition_isCorrect() {
assertEquals(4, 2 + 2);
}
} | [
"bvekp1@gmail.com"
] | bvekp1@gmail.com |
b78a69a0a35236ca75e9c83dc379e8953775697a | e40fa8032faec751915eb01760a450a63e450a20 | /src/main/java/com/odonto/ejb/UsuarioFacade.java | 78b721377224bbeff250c88cee0377b1426de490 | [] | no_license | valenovoa/ProgramaExtramural | 02bee7ed749d88e08bb8048894a8b7851f185843 | 80a30721c78e2a9d6a3c516adf11df490280e341 | refs/heads/master | 2021-01-01T18:46:59.988608 | 2017-09-03T23:03:39 | 2017-09-03T23:03:39 | 98,435,865 | 0 | 1 | null | 2017-08-02T23:54:41 | 2017-07-26T15:03:52 | Java | UTF-8 | Java | false | false | 1,243 | java |
package com.odonto.ejb;
import com.odonto.model.Usuario;
import java.util.List;
import javax.ejb.Stateless;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
@Stateless
public class UsuarioFacade extends AbstractFacade<Usuario> implements UsuarioFacadeLocal {
@PersistenceContext(unitName = "odontoPool")
private EntityManager em;
@Override
protected EntityManager getEntityManager() {
return em;
}
public UsuarioFacade() {
super(Usuario.class);
}
@Override
public Usuario iniciarSesion(Usuario us){
Usuario usuario = null;
String consulta;
try{
consulta = "FROM Usuario u WHERE u.usuario = ?1 and u.clave = ?2";
Query query = em.createQuery(consulta);
query.setParameter(1, us.getUsuario());
query.setParameter(2, us.getClave());
List<Usuario> lista = query.getResultList();
if(!lista.isEmpty()){
usuario = lista.get(0);
}
}catch(Exception e){
throw e;
}
return usuario;
}
}
| [
"valenovoan@gmail.com"
] | valenovoan@gmail.com |
69db27715959ae80697371da3bb371a156639ecf | 1de9dec258a7b1cbaad955240f0457780523b910 | /src/yang/weiwei/tools/ToolCorpusConverter.java | ff6453f7796bb739e44c91293561c3fe06f678b5 | [
"MIT"
] | permissive | ywwbill/YWWTools-v2 | b831f166ba47db17660ab6ef5c7850f7b9b916dc | cdc03c4a02adb90f06ce5052462f83e13b1865d4 | refs/heads/master | 2022-12-13T03:46:18.662010 | 2020-09-05T08:07:51 | 2020-09-05T08:07:51 | 232,361,192 | 2 | 1 | null | null | null | null | UTF-8 | Java | false | false | 2,822 | java | package yang.weiwei.tools;
import java.io.IOException;
import java.util.Properties;
import yang.weiwei.util.format.CorpusConverter;
public class ToolCorpusConverter extends ToolInterface
{
private boolean getVocab=false;
private boolean toIndex=false;
private boolean toWord=false;
private String wordCorpusFileName;
private String indexCorpusFileName;
private String vocabFileName;
public void parseCommand()
{
getVocab=Boolean.valueOf(props.getProperty("get_vocab", "false"));
toIndex=Boolean.valueOf(props.getProperty("to_index", "false"));
toWord=Boolean.valueOf(props.getProperty("to_word", "false"));
wordCorpusFileName=props.getProperty("word_corpus");
indexCorpusFileName=props.getProperty("index_corpus");
vocabFileName=props.getProperty("vocab");
}
protected boolean checkCommand()
{
if (help) return false;
int numTrue=0;
if (getVocab) numTrue++;
if (toIndex) numTrue++;
if (toWord) numTrue++;
if (numTrue!=1)
{
println("No option or multiple options are selected.");
return false;
}
if (wordCorpusFileName==null || wordCorpusFileName.length()==0)
{
println("Word corpus file is not specified.");
return false;
}
if (vocabFileName==null || vocabFileName.length()==0)
{
println("Vocabulary file is not specified.");
return false;
}
if ((toIndex || toWord) && (indexCorpusFileName==null || indexCorpusFileName.length()==0))
{
println("Index corpus file is not specified.");
return false;
}
return true;
}
public void execute() throws IOException
{
if (!checkCommand())
{
printHelp();
return;
}
if (getVocab)
{
CorpusConverter.collectVocab(wordCorpusFileName, vocabFileName);
}
if (toIndex)
{
CorpusConverter.word2Index(wordCorpusFileName, indexCorpusFileName, vocabFileName);
}
if (toWord)
{
CorpusConverter.index2Word(vocabFileName, indexCorpusFileName, wordCorpusFileName);
}
}
public void printHelp()
{
println("Arguments for corpus converter:");
println("\thelp [optional]: Print help information.");
println("\tConvert options (only one can be selected):");
println("\t\tget_vocab: Collect vocabulary from a given word corpus file.");
println("\t\tto_index: Convert a word corpus file into an indexed corpus file and collect vocabulary.");
println("\t\tto_word: Convert an indexed corpus file into a word corpus file given vocabulary.");
println("\tword_corpus: Corpus file that contains words.");
println("\tindex_corpus: Indexed corpus file. Not required when only collecting vocabulary (i.e. --get-vocab).");
println("\tvocab: Vocabulary file.");
}
public ToolCorpusConverter(String cfgFileName) throws IOException
{
super(cfgFileName);
}
public ToolCorpusConverter(Properties props)
{
super(props);
}
}
| [
"weiwei.yang.1990@gmail.com"
] | weiwei.yang.1990@gmail.com |
309f3ae8de6c2a3afeb073fb134956047571beef | 13c13a3011660445e5e7b3554432f4a45060f20d | /src/main/java/eu/webpos/service/CustomerRepo.java | 41f68959301f931ce8428f5891e5d58839758d7f | [] | no_license | Colmos85/WebPOS | 7198e36c085ba359014d3e622097ec4f837d2b92 | 11deeb267fbec9ab7567faa9c7802ad0e5eae141 | refs/heads/master | 2021-03-27T13:13:31.978081 | 2017-03-16T20:23:14 | 2017-03-16T20:23:14 | 81,465,615 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 318 | java | package eu.webpos.service;
import org.springframework.data.jpa.repository.JpaRepository;
import eu.webpos.entity.Brand;
import eu.webpos.entity.Customer;
public interface CustomerRepo extends JpaRepository<Customer, Integer>{
public int countByUsername(String username);
public Customer findById(int id);
}
| [
"colm.osullivan4@mycit.ie"
] | colm.osullivan4@mycit.ie |
079528fd577ded586a8143d51199916d9ee3143a | 3c695bdb965942bdddc0e4aa63111ee75833d55e | /app/src/main/java/com/easemob/chatuidemo/parse/ParseManager.java | 60ebc7d4c9b801bf3442d6d2fb78af9f1d0f26fe | [] | no_license | RunziiMo/CYOU | 21ad6b68df1fabd002e7ce65aa7c0629a509ec2c | 5c2153e5407128a3fd3851ee53240119cafb1cf9 | refs/heads/master | 2020-05-30T07:13:44.960090 | 2016-09-25T03:53:03 | 2016-09-25T03:53:03 | 69,142,473 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 9,955 | java | package com.easemob.chatuidemo.parse;
import java.util.ArrayList;
import java.util.List;
import android.content.Context;
import com.easemob.EMValueCallBack;
import com.easemob.chat.EMChatManager;
import com.runzii.cyou.common.utils.DemoHelper;
import com.easemob.easeui.domain.EaseUser;
import com.easemob.easeui.utils.EaseCommonUtils;
import com.easemob.util.EMLog;
import com.parse.FindCallback;
import com.parse.GetCallback;
import com.parse.Parse;
import com.parse.ParseException;
import com.parse.ParseFile;
import com.parse.ParseObject;
import com.parse.ParseQuery;
import com.parse.SaveCallback;
public class ParseManager {
private static final String TAG = ParseManager.class.getSimpleName();
private static final String ParseAppID = "UUL8TxlHwKj7ZXEUr2brF3ydOxirCXdIj9LscvJs";
private static final String ParseClientKey = "B1jH9bmxuYyTcpoFfpeVslhmLYsytWTxqYqKQhBJ";
private static final String CONFIG_TABLE_NAME = "hxuser";
private static final String CONFIG_USERNAME = "username";
private static final String CONFIG_NICK = "nickname";
private static final String CONFIG_AVATAR = "avatar";
private static final String CONFIG_SIGNATURE = "signature";
private Context appContext;
private static ParseManager instance = new ParseManager();
private ParseManager() {
}
public static ParseManager getInstance() {
return instance;
}
public void onInit(Context context) {
this.appContext = context.getApplicationContext();
Parse.enableLocalDatastore(appContext);
Parse.initialize(context, ParseAppID, ParseClientKey);
}
public boolean updateParseNickName(final String nickname) {
String username = EMChatManager.getInstance().getCurrentUser();
ParseQuery<ParseObject> pQuery = ParseQuery.getQuery(CONFIG_TABLE_NAME);
pQuery.whereEqualTo(CONFIG_USERNAME, username);
ParseObject pUser = null;
try {
pUser = pQuery.getFirst();
if (pUser == null) {
return false;
}
pUser.put(CONFIG_NICK, nickname);
pUser.save();
return true;
} catch (ParseException e) {
if (e.getCode() == ParseException.OBJECT_NOT_FOUND) {
pUser = new ParseObject(CONFIG_TABLE_NAME);
pUser.put(CONFIG_USERNAME, username);
pUser.put(CONFIG_NICK, nickname);
try {
pUser.save();
return true;
} catch (ParseException e1) {
e1.printStackTrace();
EMLog.e(TAG, "parse error " + e1.getMessage());
}
}
e.printStackTrace();
EMLog.e(TAG, "parse error " + e.getMessage());
}
return false;
}
public boolean updateParseSignature(final String signature) {
String username = EMChatManager.getInstance().getCurrentUser();
ParseQuery<ParseObject> pQuery = ParseQuery.getQuery(CONFIG_TABLE_NAME);
pQuery.whereEqualTo(CONFIG_USERNAME, username);
ParseObject pUser = null;
try {
pUser = pQuery.getFirst();
if (pUser == null) {
return false;
}
pUser.put(CONFIG_SIGNATURE, signature);
pUser.save();
return true;
} catch (ParseException e) {
if (e.getCode() == ParseException.OBJECT_NOT_FOUND) {
pUser = new ParseObject(CONFIG_TABLE_NAME);
pUser.put(CONFIG_USERNAME, username);
pUser.put(CONFIG_SIGNATURE, signature);
try {
pUser.save();
return true;
} catch (ParseException e1) {
e1.printStackTrace();
EMLog.e(TAG, "parse error " + e1.getMessage());
}
}
e.printStackTrace();
EMLog.e(TAG, "parse error " + e.getMessage());
}
return false;
}
public void getContactInfos(List<String> usernames, final EMValueCallBack<List<EaseUser>> callback) {
ParseQuery<ParseObject> pQuery = ParseQuery.getQuery(CONFIG_TABLE_NAME);
pQuery.whereContainedIn(CONFIG_USERNAME, usernames);
pQuery.findInBackground(new FindCallback<ParseObject>() {
@Override
public void done(List<ParseObject> arg0, ParseException arg1) {
if (arg0 != null) {
List<EaseUser> mList = new ArrayList<EaseUser>();
for (ParseObject pObject : arg0) {
EaseUser user = new EaseUser(pObject.getString(CONFIG_USERNAME));
ParseFile parseFile = pObject.getParseFile(CONFIG_AVATAR);
if (parseFile != null) {
user.setAvatar(parseFile.getUrl());
}
user.setNick(pObject.getString(CONFIG_NICK));
user.setSingature(pObject.getString(CONFIG_SIGNATURE));
EaseCommonUtils.setUserInitialLetter(user);
mList.add(user);
}
callback.onSuccess(mList);
} else {
callback.onError(arg1.getCode(), arg1.getMessage());
}
}
});
}
public void asyncGetCurrentUserInfo(final EMValueCallBack<EaseUser> callback) {
final String username = EMChatManager.getInstance().getCurrentUser();
asyncGetUserInfo(username, new EMValueCallBack<EaseUser>() {
@Override
public void onSuccess(EaseUser value) {
callback.onSuccess(value);
}
@Override
public void onError(int error, String errorMsg) {
if (error == ParseException.OBJECT_NOT_FOUND) {
ParseObject pUser = new ParseObject(CONFIG_TABLE_NAME);
pUser.put(CONFIG_USERNAME, username);
pUser.saveInBackground(new SaveCallback() {
@Override
public void done(ParseException arg0) {
if (arg0 == null) {
callback.onSuccess(new EaseUser(username));
}
}
});
} else {
callback.onError(error, errorMsg);
}
}
});
}
public void asyncGetUserInfo(final String username, final EMValueCallBack<EaseUser> callback) {
ParseQuery<ParseObject> pQuery = ParseQuery.getQuery(CONFIG_TABLE_NAME);
pQuery.whereEqualTo(CONFIG_USERNAME, username);
pQuery.getFirstInBackground(new GetCallback<ParseObject>() {
@Override
public void done(ParseObject pUser, ParseException e) {
if (pUser != null) {
String nick = pUser.getString(CONFIG_NICK);
String signature = pUser.getString(CONFIG_SIGNATURE);
ParseFile pFile = pUser.getParseFile(CONFIG_AVATAR);
if (callback != null) {
EaseUser user = null;
if (DemoHelper.getInstance().getContactList() != null) {
user = DemoHelper.getInstance().getContactList().get(username);
}
if (user != null) {
user.setNick(nick);
user.setSingature(signature);
if (pFile != null && pFile.getUrl() != null) {
user.setAvatar(pFile.getUrl());
}
} else {
user = new EaseUser(username);
user.setNick(nick);
user.setSingature(signature);
if (pFile != null && pFile.getUrl() != null) {
user.setAvatar(pFile.getUrl());
}
}
callback.onSuccess(user);
}
} else {
if (callback != null) {
callback.onError(e.getCode(), e.getMessage());
}
}
}
});
}
public String uploadParseAvatar(byte[] data) {
String username = EMChatManager.getInstance().getCurrentUser();
ParseQuery<ParseObject> pQuery = ParseQuery.getQuery(CONFIG_TABLE_NAME);
pQuery.whereEqualTo(CONFIG_USERNAME, username);
ParseObject pUser = null;
try {
pUser = pQuery.getFirst();
if (pUser == null) {
pUser = new ParseObject(CONFIG_TABLE_NAME);
pUser.put(CONFIG_USERNAME, username);
}
ParseFile pFile = new ParseFile(data);
pUser.put(CONFIG_AVATAR, pFile);
pUser.save();
return pFile.getUrl();
} catch (ParseException e) {
if (e.getCode() == ParseException.OBJECT_NOT_FOUND) {
try {
pUser = new ParseObject(CONFIG_TABLE_NAME);
pUser.put(CONFIG_USERNAME, username);
ParseFile pFile = new ParseFile(data);
pUser.put(CONFIG_AVATAR, pFile);
pUser.save();
return pFile.getUrl();
} catch (ParseException e1) {
e1.printStackTrace();
EMLog.e(TAG, "parse error " + e1.getMessage());
}
} else {
e.printStackTrace();
EMLog.e(TAG, "parse error " + e.getMessage());
}
}
return null;
}
}
| [
"806478101@qq.com"
] | 806478101@qq.com |
47185beb6100b28d4c80637f71f71a6f58ef89c4 | 9b40761f7b05e55422d3f5bd846ebc93d3430cd1 | /src/tms/sensors/VehicleCount.java | db8dc5f628c7ef81654d2757ae440a4eed493e8f | [] | no_license | william-cui/transport-network | 78618c0a76416253317641c976fb0f86f8f1445e | dafae98f04431bab616a51e28b54d9090f53ee0a | refs/heads/master | 2022-11-21T05:18:08.720849 | 2020-07-30T13:59:48 | 2020-07-30T13:59:48 | 283,706,288 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 314 | java | package tms.sensors;
public interface VehicleCount extends Sensor {
/**
* Returns the observed rate of vehicles travelling past this sensor in
* vehicles per minute.
*
* @return the current traffic count reported by the vehicle count sensor
* @ass2
*/
int countTraffic();
}
| [
"confggtly1971@gmail.com"
] | confggtly1971@gmail.com |
b669387db046dc4feaa3e4045845ea058e391f2e | d2e690a751cb23c68e65b36246dcffe2228953a7 | /src/main/java/org/luozhe/lzspring/controller/UserController.java | 3096e261a795333e98d0e24b7215c61b9478a104 | [] | no_license | sunLuo/luoz | 3ea9165b03535bbfb8cfa4093f059ea130b48535 | b6cd93d1c7260c9e39970095db3bdf040758a7c1 | refs/heads/master | 2022-07-15T19:34:00.150447 | 2020-10-10T06:29:10 | 2020-10-10T06:29:10 | 96,669,415 | 0 | 0 | null | 2022-06-21T02:10:10 | 2017-07-09T07:53:36 | Java | UTF-8 | Java | false | false | 339 | java | package org.luozhe.lzspring.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>
* 前端控制器
* </p>
*
* @author luozhe
* @since 2019-10-06
*/
@RestController
@RequestMapping("/lzspring/user")
public class UserController {
}
| [
"noreply@github.com"
] | noreply@github.com |
f4f287d2081fb90713dd1b08e140db87c8877855 | d29b223546871999885a64482a896f7da4af594b | /src/patronesfactory/Tijera.java | 4b7f977a889c45f39cc0b5bd7de4d1bf35f706bf | [] | no_license | alsansan/Curso-Java-1 | 296ad4934bf30abd1887f7b7d695b64564f2a29b | 7aad43134ec218a381b262d08ec29bfb4344f3d5 | refs/heads/main | 2023-08-13T22:15:10.297071 | 2021-09-30T11:52:08 | 2021-09-30T11:52:08 | 407,122,402 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 605 | java | package patronesfactory;
public class Tijera extends PiedraPapelTijeraFactory {
public Tijera() {
numero = 2;
nombre= "tijera";
}
@Override
public boolean isMe(int pNumero) {
return pNumero==2;
}
@Override
public int comparar(PiedraPapelTijeraFactory pPpt) {
//piedra0 pierde , resultado =-1
//papel 1 pierde , resultado = 1
//tiera 2 pierd (yo) , resultado = 0
int resultado=0;
switch (pPpt.numero) {
case 0:
resultado = 1;
break;
case 1:
resultado = 0;
break;
case 2:
resultado = -1;
break;
default:
break;
}
return resultado;
}
}
| [
"alberto_s.san@hotmail.com"
] | alberto_s.san@hotmail.com |
a03f47937fef39a2ae6c9ffebfeefeea81d68e32 | b905fbc16a3e4c1765ce4b4eb270d017e6b4b5d2 | /HRMS/HRMS-Services/src/main/java/com/csipl/hrms/service/employee/SeparationService.java | 98f7a492e427ad9131d83688aa9192cea5e1df2a | [] | no_license | ravindra2017bangalore/FabHR | 76ed00741be81b6219b565bb38c4c4a68a364dc1 | c77e5d4c99d5e9bdb042efea5e30fa25e7e0561e | refs/heads/master | 2021-07-03T22:56:55.877324 | 2019-03-11T15:13:02 | 2019-03-11T15:13:02 | 175,022,830 | 1 | 0 | null | null | null | null | UTF-8 | Java | false | false | 1,103 | java | package com.csipl.hrms.service.employee;
import java.util.List;
import com.csipl.hrms.dto.employee.SeparationDTO;
import com.csipl.hrms.model.employee.Separation;
public interface SeparationService {
public Separation save(Separation separation);
public List<Separation> getSeparationList(Long employeeId,Long companyId);
public List<Separation> getAllseparationList(Long companyId);
public Long checkSeparationForRequest(Long employeeId);
public Separation getSeparation(Long separationId);
public List<Separation> getAllseparationPendingList(Long companyId);
public SeparationDTO getNoticePeriodCount(Long companyId);
public SeparationDTO seperationCount(Long companyId);
public List<Separation> employeeCancelledResignReqList(Long employeeId);
public Separation employeePendingResignReq(Long employeeId);
public void updateRequestStatus(Long separationId, String status, String description);
public List<Separation> findAllSeparationPendingReqList(Long companyId);
public List<Separation> findAllSeparationExcludedPendingReqList(Long companyId);
}
| [
"parihar.ravindrasingh@gmail.com"
] | parihar.ravindrasingh@gmail.com |
79efd8f9e9d7380a0f3fe0a123fb3ed2b6953dad | cfb2ab1a86029d5fa4790001b4ac3989fa55809f | /src/main/java/com/example/ProductClientApplication.java | 651254d03139f21a6cff8de3fc5b728a39f2cd6a | [] | no_license | mrbaljit/stock-client | 94b9587a277870f3e396079f7f89b39f0e28cd56 | 318264af2e603268ca356de6d5fcfb4f5a9e51e0 | refs/heads/master | 2016-09-13T12:40:03.804004 | 2016-05-02T01:54:42 | 2016-05-02T01:54:42 | 56,291,557 | 0 | 0 | null | null | null | null | UTF-8 | Java | false | false | 317 | java | package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ProductClientApplication {
public static void main(String[] args) {
SpringApplication.run(ProductClientApplication.class, args);
}
}
| [
"baljit.singh@suncorp.co.nz"
] | baljit.singh@suncorp.co.nz |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.